Merge lp:~unity-api-team/keeper/restore into lp:keeper/devel

[Charles Kerr]

First version of restore.

DO NOT REVIEW YET, branch created for initial jenkins test

This is based on <https://code.launchpad.net/~xavi-garcia-mena/keeper/restore/> and is here so that multiple devs can kick the tires as neeed

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

FAILED: Continuous integration, rev:130
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/124/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1092/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1099
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/890/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/890/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/890/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/890/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/890/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/890/console

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

review: Needs Fixing (continuous-integration)

[lp:~unity-api-team/keeper/restore]

131. By Charles Kerr on 2016-11-16

debug messages and whitespace

132. By Charles Kerr on 2016-11-17

eliminate some possible points of failure in the RestoreReader fake

133. By Charles Kerr on 2016-11-17

add more debugging info to FileUtils::compare_files()

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

FAILED: Continuous integration, rev:133
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/125/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1093/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1100
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/891/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/891/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/891/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/891/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/891/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/891/console

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

133. By Charles Kerr on 2016-11-17

add more debugging info to FileUtils::compare_files()

132. By Charles Kerr on 2016-11-17

eliminate some possible points of failure in the RestoreReader fake

131. By Charles Kerr on 2016-11-16

debug messages and whitespace

130. By Charles Kerr on 2016-11-16

fix missing gpl copyright in keeper dbusmock template

129. By Charles Kerr on 2016-11-16

fix cppcheck warning: non-explicit object ctor taking one argument

=== modified file 'data/helper-registry.json.in'
--- data/helper-registry.json.in	2016-08-09 04:20:33 +0000
+++ data/helper-registry.json.in	2016-11-17 00:23:33 +0000
@@ -4,5 +4,10 @@
             "@FOLDER_BACKUP_EXEC@",
             "${subtype}"
         ]
-    }
+        ,
+        "restore-urls": [
+            "@FOLDER_RESTORE_EXEC@",
+            "${subtype}"
+        ]
+     }
 }
 
=== 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	2016-11-17 00:23:33 +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/metadata.h'
--- include/helper/metadata.h	2016-10-14 09:23:11 +0000
+++ include/helper/metadata.h	2016-11-17 00:23:33 +0000
@@ -42,6 +42,7 @@
     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;
 
     // metadata values
 
=== modified file 'include/helper/registry.h'
--- include/helper/registry.h	2016-08-08 04:56:35 +0000
+++ include/helper/registry.h	2016-11-17 00:23:33 +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	2016-11-17 00:23:33 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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/CMakeLists.txt'
--- src/CMakeLists.txt	2016-08-09 10:13:48 +0000
+++ src/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -11,6 +11,7 @@
 add_subdirectory(storage-framework)
 add_subdirectory(tar)
 add_subdirectory(util)
+add_subdirectory(test-restore)
 
 set(
   COVERAGE_REPORT_TARGETS
 
=== modified file 'src/cli/main.cpp'
--- src/cli/main.cpp	2016-08-30 14:16:19 +0000
+++ src/cli/main.cpp	2016-11-17 00:23:33 +0000
@@ -88,6 +88,48 @@
             qWarning() << "Error starting backup:" << backup_reply.error().message();
         }
     }
+    else if(argc == 2 && QStringLiteral("--restore") == argv[1])
+    {
+        QScopedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
+                                                                DBusTypes::KEEPER_SERVICE,
+                                                                DBusTypes::KEEPER_USER_PATH,
+                                                                QDBusConnection::sessionBus()
+                                                            ) );
+        QDBusPendingReply<QVariantDictMap> choices = user_iface->call("GetRestoreChoices");
+        choices.waitForFinished();
+        if (choices.isError())
+        {
+            qFatal("Call to '%s.GetRestoreChoices() at '%s' call failed: %s",
+                DBusTypes::KEEPER_SERVICE,
+                qPrintable(DBusTypes::KEEPER_USER_PATH),
+                qPrintable(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();
+                }
+            }
+        }
+
+        QStringList restoreUUids{uuids.at(0)};
+        QDBusPendingReply<void> backup_reply = user_iface->call("StartRestore", restoreUUids);
+
+        if (!backup_reply.isValid())
+        {
+            qWarning() << "Error starting restore:" << backup_reply.error().message();
+        }
+    }
     else
     {
         qWarning() << "FIXME";
 
=== modified file 'src/helper/CMakeLists.txt'
--- src/helper/CMakeLists.txt	2016-09-06 01:31:59 +0000
+++ src/helper/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -48,10 +48,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/data-dir-registry.cpp'
--- src/helper/data-dir-registry.cpp	2016-08-10 02:29:17 +0000
+++ src/helper/data-dir-registry.cpp	2016-11-17 00:23:33 +0000
@@ -49,15 +49,29 @@
 
     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 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,8 +87,6 @@
         return ret;
     }
 
-private:
-
     // replace "${key}" with task.get_property("key")
     QStringList perform_url_substitution(Metadata const& task, QStringList const& urls_in)
     {
@@ -139,6 +151,10 @@
              *         "backup-urls": [
              *             "/path/to/helper.sh",
              *             "${subtype}"
+             *         ],
+             *         "restore-urls": [
+             *             "/path/to/helper.sh",
+             *             "${subtype}"
              *         ]
              *     }
              * }
@@ -160,21 +176,33 @@
             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"];
                 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 +226,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/helper.cpp'
--- src/helper/helper.cpp	2016-09-15 14:05:17 +0000
+++ src/helper/helper.cpp	2016-11-17 00:23:33 +0000
@@ -301,7 +301,7 @@
 
     void ual_stop()
     {
-        qDebug() << "Stopping helper for app:" << appid_;
+        qDebug() << "------------------------------------------------------ Stopping helper for app:" << appid_;
         auto backupType = ubuntu::app_launch::Helper::Type::from_raw(HELPER_TYPE);
 
         auto appid = ubuntu::app_launch::AppID::parse(appid_.toStdString());
@@ -359,7 +359,7 @@
 
     void on_max_time_waiting_for_ual_started()
     {
-        qDebug() << "Max time reached waiting for UAL to start";
+        qDebug() << "========================================================================== Max time reached waiting for UAL to start";
         q_ptr->set_state(Helper::State::FAILED);
         stop_wait_for_ual_timer();
     }
 
=== modified file 'src/helper/metadata.cpp'
--- src/helper/metadata.cpp	2016-10-14 09:23:11 +0000
+++ src/helper/metadata.cpp	2016-11-17 00:23:33 +0000
@@ -42,6 +42,7 @@
 const QString Metadata::TITLE_KEY = QStringLiteral("title");
 const QString Metadata::VERSION_KEY = QStringLiteral("version");
 const QString Metadata::FILE_NAME_KEY = QStringLiteral("file-name");
+const QString Metadata::DIR_NAME_KEY = QStringLiteral("dir-name");
 const QString Metadata::DISPLAY_NAME_KEY = QStringLiteral("display-name");
 
 // Metadata values
 
=== added file 'src/helper/restore-helper.cpp'
--- src/helper/restore-helper.cpp	1970-01-01 00:00:00 +0000
+++ src/helper/restore-helper.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,378 @@
+/*
+ * 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 <QCryptographicHash>
+
+#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)
+        {
+            // TODO throw exception.
+            qWarning() << "RestoreHelperPrivate: error creating socket pair to communicate with helper ";
+            return;
+        }
+
+        // helper socket is for the client.
+        helper_socket_.setSocketDescriptor(fds[0], QLocalSocket::ConnectedState, QIODevice::ReadOnly);
+
+        write_socket_.setSocketDescriptor(fds[1], 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)
+    {
+        qDebug() << "RestoreHelper::set_downloader";
+        downloader_ = downloader;
+        n_read_ = 0;
+        n_uploaded_ = 0;
+        read_error_ = false;
+        write_error_ = false;
+        cancelled_ = false;
+
+        q_ptr->set_expected_size(downloader->file_size());
+
+        qDebug() << "Storage framework socket is: " << static_cast<void *>(downloader_->socket().get());
+
+        // listen for data ready to read
+        QObject::connect(downloader_->socket().get(), &QLocalSocket::readyRead,
+            std::bind(&RestoreHelperPrivate::on_ready_read, this)
+        );
+
+        connections_.remember(QObject::connect(
+            &write_socket_, &QLocalSocket::bytesWritten,
+            std::bind(&RestoreHelperPrivate::on_data_uploaded, this, std::placeholders::_1)
+        ));
+
+        // maybe there's already readable data
+        process_more();
+
+        reset_inactivity_timer();
+    }
+
+    void stop()
+    {
+        write_socket_.disconnectFromServer();
+        cancelled_ = true;
+        q_ptr->Helper::stop();
+    }
+
+    int get_helper_socket() const
+    {
+        return int(helper_socket_.socketDescriptor());
+    }
+
+    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";
+        stop();
+    }
+
+    void on_ready_read()
+    {
+        process_more();
+    }
+
+    void on_data_uploaded(qint64 n)
+    {
+        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();
+    }
+
+    void process_more()
+    {
+        qDebug() << Q_FUNC_INFO;
+
+        if (!downloader_)
+            return;
+
+        qDebug() << Q_FUNC_INFO << "2";
+
+        char readbuf[UPLOAD_BUFFER_MAX_];
+        auto socket = downloader_->socket();
+        for(;;)
+        {
+            if (!socket->bytesAvailable())
+                break;
+            // 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));
+                    qDebug("buffer_.size() is %zu after reading %zu", size_t(upload_buffer_.size()), size_t(n));
+                }
+                else if (n < 0) {
+                    read_error_ = true;
+                    qDebug() << "Read error in" << Q_FUNC_INFO << ":" << socket->errorString();
+                    stop();
+                    return;
+                }
+            }
+
+            // THIS IS JUST FOR EXTRA DEBUG INFORMATION
+            QCryptographicHash hash(QCryptographicHash::Sha1);
+            hash.addData(upload_buffer_.left(100));
+            qDebug() << "************************************************ Hash send: " << hash.result().toHex() << " Size: " << upload_buffer_.size() << " Total: " << n_read_;
+            // THIS IS JUST FOR EXTRA DEBUG INFORMATION
+
+            // try to empty the upload buf
+            const auto n = write_socket_.write(upload_buffer_);
+            if (n > 0) {
+                upload_buffer_.remove(0, int(n));
+                qDebug("buffer_.size() is %zu after writing %zu", size_t(upload_buffer_.size()), size_t(n));
+                continue;
+            }
+            else {
+                if (n < 0) {
+                    write_error_ = true;
+                    qWarning() << "Write error:" << write_socket_.errorString();
+                    stop();
+                }
+                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()
+    {
+        qDebug() << "Checking 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())
+            {
+                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_;
+    QLocalSocket helper_socket_;
+    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_;
+    QString uploader_committed_file_name_;
+};
+
+/***
+****
+***/
+
+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);
+
+    qDebug() << Q_FUNC_INFO;
+    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/service/CMakeLists.txt'
--- src/service/CMakeLists.txt	2016-10-28 15:11:21 +0000
+++ src/service/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -15,6 +15,7 @@
   task-manager.cpp
   keeper-task.cpp
   keeper-task-backup.cpp
+  keeper-task-restore.cpp
   manifest.cpp
   metadata-provider.h
 )
 
=== modified file 'src/service/keeper-helper.cpp'
--- src/service/keeper-helper.cpp	2016-08-10 02:06:08 +0000
+++ src/service/keeper-helper.cpp	2016-11-17 00:23:33 +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-10-06 14:53:44 +0000
+++ src/service/keeper-task-backup.cpp	2016-11-17 00:23:33 +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)
@@ -90,7 +90,7 @@
     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)
 
=== modified file 'src/service/keeper-task-backup.h'
--- src/service/keeper-task-backup.h	2016-10-06 14:53:44 +0000
+++ src/service/keeper-task-backup.h	2016-11-17 00:23:33 +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);
 
=== 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	2016-11-17 00:23:33 +0000
@@ -0,0 +1,129 @@
+/*
+ * 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()
+    {
+        qDebug() << Q_FUNC_INFO;
+        helper_.reset(new RestoreHelper(DEKKO_APP_ID), [](Helper *h){h->deleteLater();}); // TODO change this to a restore helper
+        qDebug() << "Helper " <<  static_cast<void*>(helper_.data()) << " was created";
+    }
+
+    void ask_for_downloader()
+    {
+        qDebug() << "asking storage framework for a socket for reading";
+
+        QString file_name;
+        task_data_.metadata.get_property(Metadata::FILE_NAME_KEY, file_name);
+        if (file_name.isEmpty())
+        {
+            qWarning() << "ERROR: the restore task does not provide a valid file name to read from.";
+            return;
+        }
+
+        QString dir_name;
+        task_data_.metadata.get_property(Metadata::DIR_NAME_KEY, 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){
+                    qDebug() << "Downloader is" << static_cast<void*>(downloader.get());
+                    int fd {-1};
+                    if (downloader) {
+                        qDebug() << "Helper is " <<  static_cast<void*>(helper_.data());
+                        auto restore_helper = qSharedPointerDynamicCast<RestoreHelper>(helper_);
+                        restore_helper->set_downloader(downloader);
+                        fd = restore_helper->get_helper_socket();
+                    }
+                    qDebug("emitting task_socket_ready(socket=%d)", fd);
+                    Q_EMIT(q_ptr->task_socket_ready(fd));
+                }
+            }
+        );
+    }
+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	2016-11-17 00:23:33 +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-30 09:23:09 +0000
+++ src/service/keeper-task.cpp	2016-11-17 00:23:33 +0000
@@ -28,7 +28,7 @@
 #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)
@@ -132,7 +132,7 @@
     auto const percent_done = helper_->percent_done();
     ret.insert(QStringLiteral("percent-done"), double(percent_done));
 
-    if (task_data_.action == "failed")
+    if (task_data_.action == "failed" || task_data_.action == "cancelled")
         ret.insert(QStringLiteral("error"), task_data_.error);
 
     ret.insert(QStringLiteral("uuid"), uuid);
@@ -145,8 +145,13 @@
 
 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()
@@ -175,7 +180,20 @@
     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";
+    }
+}
+
+KeeperTask::KeeperTask(TaskData & task_data,
                        QSharedPointer<HelperRegistry> const & helper_registry,
                        QSharedPointer<StorageFrameworkClient> const & storage,
                        QObject *parent)
@@ -207,6 +225,14 @@
     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);
@@ -218,3 +244,10 @@
 
     return d->cancel();
 }
+
+QString KeeperTask::to_string(Helper::State state)
+{
+    Q_D(KeeperTask);
+
+    return d->to_string(state);
+}
 
=== modified file 'src/service/keeper-task.h'
--- src/service/keeper-task.h	2016-09-28 13:42:21 +0000
+++ src/service/keeper-task.h	2016-11-17 00:23:33 +0000
@@ -44,7 +44,7 @@
         Metadata metadata;
     };
 
-    KeeperTask(TaskData const & task_data,
+    KeeperTask(TaskData & task_data,
                QSharedPointer<HelperRegistry> const & helper_registry,
                QSharedPointer<StorageFrameworkClient> const & storage,
                QObject *parent = nullptr);
@@ -54,11 +54,13 @@
 
     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);
 Q_SIGNALS:
     void task_state_changed(Helper::State state);
     void task_socket_ready(int socket_descriptor);
 
=== modified file 'src/service/keeper-user.cpp'
--- src/service/keeper-user.cpp	2016-10-28 15:11:21 +0000
+++ src/service/keeper-user.cpp	2016-11-17 00:23:33 +0000
@@ -70,9 +70,11 @@
 void
 KeeperUser::StartRestore (const QStringList& keys)
 {
-    // FIXME: writeme
+    Q_ASSERT(calledFromDBus());
 
-    qDebug() << keys;
+    auto bus = connection();
+    auto& msg = message();
+    keeper_.start_tasks(keys, bus, msg, true);
 }
 
 QVariantDictMap
 
=== modified file 'src/service/keeper.cpp'
--- src/service/keeper.cpp	2016-10-28 15:11:21 +0000
+++ src/service/keeper.cpp	2016-11-17 00:23:33 +0000
@@ -76,14 +76,25 @@
     {
     }
 
+    enum class ChoicesType { BACKUP_CHOICES, RESTORES_CHOICES };
+
     ~KeeperPrivate() =default;
 
     Q_DISABLE_COPY(KeeperPrivate)
 
     void start_tasks(QStringList const & uuids,
-                            QDBusConnection bus,
-                            QDBusMessage const & msg)
+                     QDBusConnection bus,
+                     QDBusMessage const & msg,
+                     bool reset_cached_choices)
     {
+        if (reset_cached_choices)
+        {
+            // 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.
+            cached_backup_choices_.clear();
+        }
+
         auto get_tasks = [](const QVector<Metadata>& pool, QStringList const& keys){
             QMap<QString,Metadata> tasks;
             for (auto const& key : keys) {
@@ -95,9 +106,10 @@
         };
 
         // async part
+        qDebug() << "Looking for backup options....";
         connections_.connect_oneshot(
             this,
-            &KeeperPrivate::choices_ready,
+            &KeeperPrivate::backup_choices_ready,
             std::function<void()>{[this, uuids, msg, bus, get_tasks](){
                 auto tasks = get_tasks(cached_backup_choices_, uuids);
                 if (!tasks.empty())
@@ -114,12 +126,15 @@
                 }
                 else // restore
                 {
+                    qDebug() << "Looking for restore options....";
                     connections_.connect_oneshot(
                         this,
-                        &KeeperPrivate::choices_ready,
+                        &KeeperPrivate::restore_choices_ready,
                         std::function<void()>{[this, uuids, msg, bus, get_tasks](){
+                            qDebug() << "Choices ready";
                             auto unhandled = QSet<QString>::fromList(uuids);
                             auto restore_tasks = get_tasks(cached_restore_choices_, uuids);
+                            qDebug() << "After getting tasks...";
                             if (!restore_tasks.empty() && task_manager_.start_restore(restore_tasks.values()))
                                 unhandled.subtract(QSet<QString>::fromList(restore_tasks.keys()));
 
@@ -130,34 +145,58 @@
                             bus.send(reply);
                         }}
                     );
-                    get_restore_choices();
+                    get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);
                 }
             }}
         );
 
-        get_backup_choices();
+        get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);
         msg.setDelayedReply(true);
     }
 
-    void get_backup_choices()
-    {
-        if (cached_backup_choices_.isEmpty())
+    void emit_choices_ready(ChoicesType type)
+    {
+        switch(type)
+        {
+        case KeeperPrivate::ChoicesType::BACKUP_CHOICES:
+            Q_EMIT(backup_choices_ready());
+            break;
+        case KeeperPrivate::ChoicesType::RESTORES_CHOICES:
+            Q_EMIT(restore_choices_ready());
+            break;
+        }
+    }
+    void get_choices(const QSharedPointer<MetadataProvider> & provider, ChoicesType type)
+    {
+        qDebug() << Q_FUNC_INFO;
+        bool check_empty = (type == KeeperPrivate::ChoicesType::BACKUP_CHOICES)
+                            ? cached_backup_choices_.isEmpty() : cached_restore_choices_.isEmpty();
+        if (check_empty)
         {
             connections_.connect_oneshot(
-                backup_choices_.data(),
+                provider.data(),
                 &MetadataProvider::finished,
-                std::function<void()>{[this](){
-                    qDebug() << "Get backups finished";
-                    cached_backup_choices_ = backup_choices_->get_backups();
-                    Q_EMIT(choices_ready());
+                std::function<void()>{[this, provider, type](){
+                    qDebug() << "Get choices finished";
+                    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);
                 }}
             );
 
-            backup_choices_->get_backups_async();
+            provider->get_backups_async();
         }
         else
         {
-            Q_EMIT(choices_ready());
+            qDebug() << "emit choices_ready()";
+            emit_choices_ready(type);
         }
     }
 
@@ -166,7 +205,7 @@
     {
         connections_.connect_oneshot(
             this,
-            &KeeperPrivate::choices_ready,
+            &KeeperPrivate::backup_choices_ready,
             std::function<void()>{[this, msg, bus](){
                 qDebug() << "Backup choices are ready";
                 // reply now to the dbus call
@@ -176,7 +215,7 @@
             }}
         );
 
-        get_backup_choices();
+        get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);
         msg.setDelayedReply(true);
         return QVariantDictMap();
     }
@@ -186,7 +225,7 @@
     {
         connections_.connect_oneshot(
             this,
-            &KeeperPrivate::choices_ready,
+            &KeeperPrivate::restore_choices_ready,
             std::function<void()>{[this, msg, bus](){
                 qDebug() << "Restore choices are ready";
                 // reply now to the dbus call
@@ -196,34 +235,11 @@
             }}
         );
 
-        get_restore_choices();
+        get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);
         msg.setDelayedReply(true);
         return QVariantDictMap();
     }
 
-    // TODO REFACTOR THIS TO USE THE SAME METHOD POR RESTORES AND BACKUPS
-    void get_restore_choices()
-    {
-        if (cached_restore_choices_.isEmpty())
-        {
-            connections_.connect_oneshot(
-                restore_choices_.data(),
-                &MetadataProvider::finished,
-                std::function<void()>{[this](){
-                    qDebug() << "Get restores finished";
-                    cached_restore_choices_ = restore_choices_->get_backups();
-                    Q_EMIT(choices_ready());
-                }}
-            );
-
-            restore_choices_->get_backups_async();
-        }
-        else
-        {
-            Q_EMIT(choices_ready());
-        }
-    }
-
     QVariantDictMap get_state() const
     {
         return task_manager_.get_state();
@@ -233,7 +249,7 @@
                                          QDBusMessage const & msg,
                                          quint64 n_bytes)
     {
-        qDebug("Keeper::StartBackup(n_bytes=%zu)", size_t(n_bytes));
+        qDebug() << Q_FUNC_INFO << "n_bytes:" << n_bytes;
 
         connections_.connect_oneshot(
             &task_manager_,
@@ -248,7 +264,7 @@
             }
         );
 
-        qDebug() << "Asking for an storage framework socket to the task manager";
+        qDebug() << "Asking TaskManager for a socket to upload to";
         task_manager_.ask_for_uploader(n_bytes);
 
         // tell the caller that we'll be responding async
@@ -256,12 +272,41 @@
         return QDBusUnixFileDescriptor(0);
     }
 
+
+    QDBusUnixFileDescriptor start_restore(QDBusConnection bus,
+                                          QDBusMessage const & msg)
+    {
+        qDebug() << Q_FUNC_INFO;
+
+        connections_.connect_oneshot(
+            &task_manager_,
+            &TaskManager::socket_ready,
+            std::function<void(int)>{
+                [bus,msg](int fd){
+                    qDebug("TaskManager::ask_for_downloader() returned socket %d", fd);
+                    auto reply = msg.createReply();
+                    reply << QVariant::fromValue(QDBusUnixFileDescriptor(fd));
+                    bus.send(reply);
+                }
+            }
+        );
+
+        qDebug() << "Asking TaskManager for a socket to download from";
+        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();
     }
+
 Q_SIGNALS:
-    void choices_ready();
+    void backup_choices_ready();
+    void restore_choices_ready();
 
 private:
 
@@ -305,11 +350,12 @@
 void
 Keeper::start_tasks(QStringList const & uuids,
                     QDBusConnection bus,
-                    QDBusMessage const & msg)
+                    QDBusMessage const & msg,
+                    bool reset_cached_choices)
 {
     Q_D(Keeper);
 
-    d->start_tasks(uuids, bus, msg);
+    d->start_tasks(uuids, bus, msg, reset_cached_choices);
 }
 
 QDBusUnixFileDescriptor
@@ -322,6 +368,15 @@
     return d->start_backup(bus, msg, n_bytes);
 }
 
+QDBusUnixFileDescriptor
+Keeper::StartRestore(QDBusConnection bus,
+                    QDBusMessage const & msg)
+{
+    Q_D(Keeper);
+
+    return d->start_restore(bus, msg);
+}
+
 QVariantDictMap
 Keeper::get_backup_choices_var_dict_map(QDBusConnection bus,
                                         QDBusMessage const & msg)
 
=== modified file 'src/service/keeper.h'
--- src/service/keeper.h	2016-10-28 15:11:21 +0000
+++ src/service/keeper.h	2016-11-17 00:23:33 +0000
@@ -59,9 +59,14 @@
                                         QDBusMessage const & message,
                                         quint64 nbytes);
 
+
+    QDBusUnixFileDescriptor StartRestore(QDBusConnection,
+                                        QDBusMessage const & message);
+
     void start_tasks(QStringList const & uuids,
                             QDBusConnection bus,
-                            QDBusMessage const & msg);
+                            QDBusMessage const & msg,
+                            bool reset_cached_choices = false);
 
     QVariantDictMap get_state() const;
 
 
=== modified file 'src/service/manifest.cpp'
--- src/service/manifest.cpp	2016-10-13 12:22:31 +0000
+++ src/service/manifest.cpp	2016-11-17 00:23:33 +0000
@@ -110,8 +110,8 @@
     {
         connections_.connect_future(
             storage_->get_new_downloader(dir_, MANIFEST_FILE_NAME),
-            std::function<void(sf::Downloader::SPtr const&)>{
-                [this](sf::Downloader::SPtr const& downloader){
+            std::function<void(std::shared_ptr<Downloader> const&)>{
+                [this](std::shared_ptr<Downloader> const& downloader){
                     qDebug() << "Manifest downloader is" << static_cast<void*>(downloader.get());
                     if (downloader)
                     {
@@ -125,7 +125,7 @@
                         }
                         auto json_content = socket->readAll();
                         from_json(json_content);
-                        downloader->finish_download();
+                        downloader->finish();
                         finish();
                     }
                     else
 
=== modified file 'src/service/private/keeper-task_p.h'
--- src/service/private/keeper-task_p.h	2016-09-28 13:42:21 +0000
+++ src/service/private/keeper-task_p.h	2016-11-17 00:23:33 +0000
@@ -26,7 +26,7 @@
      Q_DECLARE_PUBLIC(KeeperTask)
 public:
     KeeperTaskPrivate(KeeperTask * keeper_task,
-                      KeeperTask::TaskData const & task_data,
+                      KeeperTask::TaskData & task_data,
                       QSharedPointer<HelperRegistry> const & helper_registry,
                       QSharedPointer<StorageFrameworkClient> const & storage);
 
@@ -40,17 +40,19 @@
 
     static QVariantMap get_initial_state(KeeperTask::TaskData const &td);
 
+    QString to_string(Helper::State state);
 protected:
     void set_current_task_action(QString const& action);
     void on_helper_percent_done_changed(float percent_done);
     QVariantMap calculate_task_state();
     void calculate_and_notify_state(Helper::State state);
+    void recalculate_task_state();
     void on_backup_socket_ready(std::shared_ptr<QLocalSocket> const &  sf_socket);
 
     virtual void on_helper_state_changed(Helper::State state);
 
     KeeperTask * const q_ptr;
-    KeeperTask::TaskData task_data_;
+    KeeperTask::TaskData & task_data_;
     QSharedPointer<HelperRegistry> helper_registry_;
     QSharedPointer<StorageFrameworkClient> storage_;
     QSharedPointer<Helper> helper_;
 
=== modified file 'src/service/task-manager.cpp'
--- src/service/task-manager.cpp	2016-11-03 10:32:49 +0000
+++ src/service/task-manager.cpp	2016-11-17 00:23:33 +0000
@@ -20,6 +20,7 @@
 
 #include "helper/metadata.h"
 #include "keeper-task-backup.h"
+#include "keeper-task-restore.h"
 #include "manifest.h"
 #include "storage-framework/storage_framework_client.h"
 #include "task-manager.h"
@@ -50,6 +51,7 @@
 
     bool start_restore(QList<Metadata> const& tasks)
     {
+        qDebug() << "Starting restore...";
         return start_tasks(tasks, Mode::RESTORE);
     }
 
@@ -78,6 +80,23 @@
         }
     }
 
+    void ask_for_downloader()
+    {
+        qDebug() << Q_FUNC_INFO;
+
+        if (task_)
+        {
+            auto restore_task_ = qSharedPointerDynamicCast<KeeperTaskRestore>(task_);
+            if (!restore_task_)
+            {
+                qWarning() << "Only restore tasks are allowed to ask for storage framework downloaders";
+                // TODO Mark this as an error at the current task and move to the next task
+                return;
+            }
+            restore_task_->ask_for_downloader();
+        }
+    }
+
     void cancel()
     {
         if (task_)
@@ -140,19 +159,40 @@
         return success;
     }
 
+    void manifest_stored(bool success)
+    {
+        qDebug() << "Manifest upload finished success = " << success << " current task=" << current_task_;
+        auto& td = task_data_[current_task_];
+        if (success)
+        {
+            update_task_state(td);
+        }
+        else
+        {
+            td.error = "Error storing manifest file";
+            set_current_task_action(task_->to_string(Helper::State::FAILED));
+        }
+        active_manifest_.reset();
+    }
+
     void on_helper_state_changed(Helper::State state)
     {
-        qDebug() << "Task State changed";
+        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)
+            update_task_state(td);
+
         if (state == Helper::State::COMPLETE || state == Helper::State::FAILED)
         {
-            auto backup_task_ = qSharedPointerDynamicCast<KeeperTaskBackup>(task_);
             if (backup_task_ && state == Helper::State::COMPLETE && active_manifest_)
             {
                 qDebug() << "Backup task finished. The file created in storage framework is: [" << backup_task_->get_file_name() << "]";
                 td.metadata.set_property(Metadata::FILE_NAME_KEY, backup_task_->get_file_name());
+                td.metadata.set_property(Metadata::DIR_NAME_KEY, backup_dir_name_);
                 active_manifest_->add_entry(td.metadata);
             }
             if (remaining_tasks_.size())
@@ -162,9 +202,6 @@
             }
             else
             {
-                // TODO we should revisit this.
-                // TODO Maybe we could treat the manifest storage as a new task (with a different task type) to check
-                // TODO when all tasks are finished and prompt something to the user.
                 if (active_manifest_ && active_manifest_->get_entries().size())
                 {
                     qDebug() << "STORING MANIFEST------------";
@@ -172,11 +209,7 @@
                         active_manifest_.data(),
                         &Manifest::finished,
                         std::function<void(bool)>{[this](bool success){
-                            if (!success)
-                                qWarning() << "Manifest store finished with error: " << active_manifest_->error();
-                            else
-                                qDebug() << "Manifest store finished successfully";
-                            active_manifest_.reset();
+                            manifest_stored(success);
                         }}
                     );
                     active_manifest_->store();
@@ -203,14 +236,16 @@
         qDebug() << "Creating task for uuid = " << uuid;
         // initialize a new task
 
-        task_.data()->disconnect();
+        if (task_)
+            task_.data()->disconnect();
+
         if (mode_ == Mode::BACKUP)
         {
             task_.reset(new KeeperTaskBackup(td, helper_registry_, storage_));
         }
         else
         {
-            // TODO initialize a Restore task
+            task_.reset(new KeeperTaskRestore(td, helper_registry_, storage_));
         }
 
         qDebug() << "task created: " << state_;
@@ -311,6 +346,7 @@
     {
         auto& td = task_data_[current_task_];
         td.action = action;
+        task_->recalculate_task_state();
         update_task_state(td);
     }
 
@@ -381,6 +417,13 @@
     d->ask_for_uploader(n_bytes);
 }
 
+void TaskManager::ask_for_downloader()
+{
+    Q_D(TaskManager);
+
+    d->ask_for_downloader();
+}
+
 void TaskManager::cancel()
 {
     Q_D(TaskManager);
 
=== modified file 'src/service/task-manager.h'
--- src/service/task-manager.h	2016-09-28 13:42:21 +0000
+++ src/service/task-manager.h	2016-11-17 00:23:33 +0000
@@ -58,6 +58,8 @@
 
     void ask_for_uploader(quint64 n_bytes);
 
+    void ask_for_downloader();
+
     void cancel();
 
 Q_SIGNALS:
 
=== modified file 'src/storage-framework/CMakeLists.txt'
--- src/storage-framework/CMakeLists.txt	2016-09-05 17:24:18 +0000
+++ src/storage-framework/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -11,6 +11,9 @@
   uploader.h
   sf-uploader.cpp
   sf-uploader.h
+  downloader.h
+  sf-downloader.cpp
+  sf-downloader.h
 )
 
 set_target_properties(
 
=== added file 'src/storage-framework/downloader.h'
--- src/storage-framework/downloader.h	1970-01-01 00:00:00 +0000
+++ src/storage-framework/downloader.h	2016-11-17 00:23:33 +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:
+ *   Charles Kerr <[e-mail]>
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+
+#pragma once
+
+#include <QLocalSocket>
+#include <QObject>
+
+#include <memory>
+
+class Downloader: public QObject
+{
+    Q_OBJECT
+
+public:
+
+    Q_DISABLE_COPY(Downloader)
+
+    Downloader(QObject *parent=nullptr): QObject(parent) {}
+    virtual ~Downloader() =default;
+
+    virtual std::shared_ptr<QLocalSocket> socket() =0;
+    virtual void finish() =0;
+    virtual qint64 file_size() const =0;
+
+Q_SIGNALS:
+
+    void download_finished();
+};
 
=== added file 'src/storage-framework/sf-downloader.cpp'
--- src/storage-framework/sf-downloader.cpp	1970-01-01 00:00:00 +0000
+++ src/storage-framework/sf-downloader.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,71 @@
+/*
+ * 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:
+ *   Charles Kerr <[e-mail]>
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+
+#include "storage-framework/sf-downloader.h"
+
+#include <QFuture>
+#include <QFutureWatcher>
+
+StorageFrameworkDownloader::StorageFrameworkDownloader(
+    unity::storage::qt::client::Downloader::SPtr const& downloader,
+    qint64 file_size,
+    QObject *parent
+):
+    Downloader(parent),
+    downloader_(downloader),
+    file_size_(file_size)
+{
+    qDebug() << "StorageFrameworkDownloader";
+}
+
+std::shared_ptr<QLocalSocket>
+StorageFrameworkDownloader::socket()
+{
+    return downloader_->socket();
+}
+
+void
+StorageFrameworkDownloader::finish()
+{
+    qDebug() << Q_FUNC_INFO << "is finishing";
+
+//    connections_.connect_future(
+//        uploader_->finish_upload(),
+//        std::function<void(std::shared_ptr<unity::storage::qt::client::File> const&)>{
+//            [this](std::shared_ptr<unity::storage::qt::client::File> const& file){
+//                auto const success = bool(file);
+//                qDebug() << "commit finished with" << success;
+//                if (success)
+//                {
+//                    file_name_after_commit_ = file->name();
+//                }
+//                Q_EMIT(commit_finished(success));
+//            }
+//        }
+//    );
+    downloader_->finish_download();
+    Q_EMIT(download_finished()); // TODO add the code to call finish_download
+}
+
+qint64
+StorageFrameworkDownloader::file_size() const
+{
+    return file_size_;
+}
 
=== added file 'src/storage-framework/sf-downloader.h'
--- src/storage-framework/sf-downloader.h	1970-01-01 00:00:00 +0000
+++ src/storage-framework/sf-downloader.h	2016-11-17 00:23:33 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#pragma once
+
+#include "util/connection-helper.h"
+#include "storage-framework/downloader.h"
+
+#include <unity/storage/qt/client/client-api.h>
+
+#include <QLocalSocket>
+
+#include <memory>
+
+class StorageFrameworkDownloader final: public Downloader
+{
+public:
+
+    StorageFrameworkDownloader(unity::storage::qt::client::Downloader::SPtr const& uploader,
+                               qint64 file_size,
+                               QObject * parent = nullptr);
+    std::shared_ptr<QLocalSocket> socket() override;
+    void finish() override;
+    qint64 file_size() const override;
+
+private:
+
+    unity::storage::qt::client::Downloader::SPtr const downloader_;
+    qint64 file_size_;
+
+    ConnectionHelper connections_;
+};
 
=== modified file 'src/storage-framework/storage_framework_client.cpp'
--- src/storage-framework/storage_framework_client.cpp	2016-11-03 10:32:49 +0000
+++ src/storage-framework/storage_framework_client.cpp	2016-11-17 00:23:33 +0000
@@ -19,6 +19,7 @@
  */
 
 #include "storage-framework/storage_framework_client.h"
+#include "storage-framework/sf-downloader.h"
 #include "storage-framework/sf-uploader.h"
 
 #include <QDateTime>
@@ -39,7 +40,7 @@
 {
 }
 
-StorageFrameworkClient::~StorageFrameworkClient() =default;
+StorageFrameworkClient::~StorageFrameworkClient() = default;
 
 /***
 ****
@@ -154,10 +155,10 @@
     return fi.future();
 }
 
-QFuture<sf::Downloader::SPtr>
+QFuture<std::shared_ptr<Downloader>>
 StorageFrameworkClient::get_new_downloader(QString const & dir_name, QString const & file_name)
 {
-    QFutureInterface<sf::Downloader::SPtr> fi;
+    QFutureInterface<std::shared_ptr<Downloader>> fi;
 
     add_roots_task([this, fi, dir_name, file_name](QVector<sf::Root::SPtr> const& roots)
     {
@@ -171,7 +172,7 @@
                         if (!keeper_root)
                         {
                             qWarning() << "Error accessing keeper root folder";
-                            sf::Downloader::SPtr ret;
+                            std::shared_ptr<Downloader> ret;
                             QFutureInterface<decltype(ret)> qfi(fi);
                             qfi.reportResult(ret);
                             qfi.reportFinished();
@@ -183,27 +184,27 @@
                                 get_storage_framework_file(keeper_root, file_name),
                                 std::function<void(sf::File::SPtr const&)>{
                                     [this, fi](sf::File::SPtr const& sf_file){
-                                        sf::Downloader::SPtr ret_null;
                                         if (sf_file) {
                                             connection_helper_.connect_future(
                                                 sf_file->create_downloader(),
                                                 std::function<void(sf::Downloader::SPtr const&)>{
-                                                    [this, fi, ret_null](sf::Downloader::SPtr const& sf_downloader){
-                                                        QFutureInterface<decltype(ret_null)> qfi(fi);
+                                                    [this, fi, sf_file](sf::Downloader::SPtr const& sf_downloader){
+                                                        std::shared_ptr<Downloader> ret;
                                                         if (sf_downloader)
                                                         {
-                                                            qfi.reportResult(sf_downloader);
-                                                            qfi.reportFinished();
-                                                        }
-                                                        else
-                                                        {
-                                                            qfi.reportResult(ret_null);
-                                                            qfi.reportFinished();
-                                                        }
+                                                            ret.reset(
+                                                                new StorageFrameworkDownloader(sf_downloader, sf_file->size(), this),
+                                                                [](Downloader* d){d->deleteLater();}
+                                                            );
+                                                        }
+                                                        QFutureInterface<decltype(ret)> qfi(fi);
+                                                        qfi.reportResult(ret);
+                                                        qfi.reportFinished();
                                                     }
                                                 }
                                             );
                                         } else {
+                                            std::shared_ptr<Downloader> ret_null;
                                             QFutureInterface<decltype(ret_null)> qfi(fi);
                                             qfi.reportResult(ret_null);
                                             qfi.reportFinished();
 
=== modified file 'src/storage-framework/storage_framework_client.h'
--- src/storage-framework/storage_framework_client.h	2016-11-03 10:32:49 +0000
+++ src/storage-framework/storage_framework_client.h	2016-11-17 00:23:33 +0000
@@ -22,6 +22,7 @@
 
 #include "util/connection-helper.h"
 #include "storage-framework/uploader.h"
+#include "storage-framework/downloader.h"
 
 #include <unity/storage/qt/client/client-api.h>
 
@@ -43,7 +44,7 @@
     virtual ~StorageFrameworkClient();
 
     QFuture<std::shared_ptr<Uploader>> get_new_uploader(int64_t n_bytes, QString const & dir_name, QString const & file_name);
-    QFuture<unity::storage::qt::client::Downloader::SPtr> get_new_downloader(QString const & dir_name, QString const & file_name);
+    QFuture<std::shared_ptr<Downloader>> get_new_downloader(QString const & dir_name, QString const & file_name);
     QFuture<QVector<QString>> get_keeper_dirs();
 
     static QString const KEEPER_FOLDER;
 
=== added directory 'src/test-restore'
=== added file 'src/test-restore/CMakeLists.txt'
--- src/test-restore/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/test-restore/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -0,0 +1,40 @@
+set(TEST_RESTORE_EXEC "test-restore-socket")
+
+include_directories("${CMAKE_SOURCE_DIR}/src")
+include_directories("${CMAKE_BINARY_DIR}/src/qdbus-stubs")
+include_directories("${CMAKE_SOURCE_DIR}/src/qdbus-stubs")
+
+set(TEST_RESTORE_SOURCES
+  main.cpp
+  test-restore-socket.cpp
+)
+
+add_executable(
+  ${TEST_RESTORE_EXEC}
+  ${TEST_RESTORE_SOURCES}
+)
+
+link_directories(
+  ${SERVICE_DEPS_LIBRARY_DIRS}
+)
+
+set(
+  RESTORE_STATIC_LIBS
+  storage-framework
+  util
+#  qdbus-stubs
+)
+
+target_link_libraries(
+  ${TEST_RESTORE_EXEC}
+  ${RESTORE_STATIC_LIBS}
+  ${SERVICE_DEVEL_SF_DEPS_LIBRARIES}
+  Qt5::Core
+  Qt5::DBus
+)
+
+install(
+  TARGETS
+    ${TEST_RESTORE_EXEC}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}
+)
 
=== added file 'src/test-restore/main.cpp'
--- src/test-restore/main.cpp	1970-01-01 00:00:00 +0000
+++ src/test-restore/main.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,32 @@
+/*
+ * 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:
+ *   Charles Kerr <[e-mail]>
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+#include <QCoreApplication>
+
+#include "test-restore-socket.h"
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+
+    TestRestoreSocket test_restore;
+    test_restore.start("test_dir", "test_file");
+
+    return app.exec();
+}
 
=== added file 'src/test-restore/test-restore-socket.cpp'
--- src/test-restore/test-restore-socket.cpp	1970-01-01 00:00:00 +0000
+++ src/test-restore/test-restore-socket.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,139 @@
+/*
+ * 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:
+ *   Charles Kerr <[e-mail]>
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+
+#include "test-restore-socket.h"
+
+#include "storage-framework/storage_framework_client.h"
+#include "storage-framework/sf-downloader.h"
+
+constexpr int UPLOAD_BUFFER_MAX_ {1024*16};
+
+TestRestoreSocket::TestRestoreSocket(QObject *parent)
+    : QObject(parent)
+    , sf_client_(new StorageFrameworkClient)
+    , file_("/tmp/test-downloader")
+{
+    file_.open(QIODevice::WriteOnly);
+    connect (&future_watcher_, &QFutureWatcher<std::shared_ptr<Downloader>>::finished, [this]{on_socket_received(future_watcher_.result());});
+}
+
+TestRestoreSocket::~TestRestoreSocket() = default;
+
+void TestRestoreSocket::start(QString const & dir_name, QString const & file_name)
+{
+    qDebug() << "asking storage framework for a socket for reading";
+
+    future_watcher_.setFuture(sf_client_->get_new_downloader(dir_name, file_name));
+//    connections_.connect_future(
+//        sf_client_->get_new_downloader(dir_name, file_name),
+//        std::function<void(std::shared_ptr<Downloader> const&)>{
+//            [this](std::shared_ptr<Downloader> const& downloader){
+//                qDebug() << "Downloader is" << static_cast<void*>(downloader.get());
+//                if (downloader) {
+//                      this->on_socket_received(downloader);
+//                }
+//            }
+//        }
+//    );
+}
+
+void TestRestoreSocket::read_data()
+{
+    if (socket_->bytesAvailable())
+    {
+////        char readbuf[UPLOAD_BUFFER_MAX_];
+////        const auto n = socket_->read(readbuf, sizeof(readbuf));
+////        if (n > 0) {
+////            n_read_ += n;
+////            qDebug() << "Read " << n << " bytes. Total: " << n_read_;
+//
+//        char readbuf[64 *1024];
+//        // 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;
+//                qDebug() << "Read " << n << " bytes. Total: " << n_read_;
+//
+////                if (file_.isOpen())
+////                {
+////                    file_.write(readbuf, max_bytes);
+////                }
+////            }
+////            else if (n < 0) {
+////                qDebug() << "Read error: " << socket_->errorString();
+////                return;
+//            if (file_.isOpen())
+//            {
+//                file_.write(readbuf, n);
+//            }
+//        }
+//        else if (n < 0) {
+//            qDebug() << "Read error: " << socket_->errorString();
+//            return;
+//        }
+//    }
+
+                char readbuf[64 *1024];
+                const auto n = socket_->read(readbuf, sizeof(readbuf));
+                if (n > 0) {
+                    n_read_ += n;
+                    qDebug() << "Read " << n << " bytes. Total: " << n_read_;
+                    if (file_.isOpen())
+                    {
+                        file_.write(readbuf, n);
+                    }
+                }
+                else if (n < 0) {
+                    qDebug() << "Read error: " << socket_->errorString();
+                    return;
+                }
+    }
+}
+
+void TestRestoreSocket::on_disconnected()
+{
+    qDebug() << "Socket disconnected";
+    auto avail = socket_->bytesAvailable();
+    while (avail > 0)
+    {
+       read_data();
+       avail = socket_->bytesAvailable();
+    }
+
+    if (file_.isOpen())
+    {
+        file_.close();
+    }
+}
+
+void TestRestoreSocket::on_data_stored(qint64 /*n*/)
+{
+    read_data();
+}
+
+void TestRestoreSocket::on_socket_received(std::shared_ptr<Downloader> const & downloader)
+{
+    socket_ = downloader->socket();
+    QObject::connect(socket_.get(), &QLocalSocket::readyRead, this, &TestRestoreSocket::read_data);
+    QObject::connect(socket_.get(), &QLocalSocket::disconnected, this, &TestRestoreSocket::on_disconnected);
+    QObject::connect(&file_, &QIODevice::bytesWritten, this, &TestRestoreSocket::on_data_stored);
+}
 
=== added file 'src/test-restore/test-restore-socket.h'
--- src/test-restore/test-restore-socket.h	1970-01-01 00:00:00 +0000
+++ src/test-restore/test-restore-socket.h	2016-11-17 00:23:33 +0000
@@ -0,0 +1,56 @@
+/*
+ * 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:
+ *   Charles Kerr <[e-mail]>
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+#pragma once
+
+#include "util/connection-helper.h"
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QFile>
+
+#include <memory>
+
+class QLocalSocket;
+class StorageFrameworkClient;
+class Downloader;
+
+class TestRestoreSocket : public QObject
+{
+    Q_OBJECT
+public:
+    explicit TestRestoreSocket(QObject *parent = nullptr);
+    virtual ~TestRestoreSocket();
+
+    void start(QString const & dir_name, QString const & file_name);
+
+public Q_SLOTS:
+    void read_data();
+    void on_socket_received(std::shared_ptr<Downloader> const & downloader);
+    void on_disconnected();
+    void on_data_stored(qint64 n);
+
+private:
+    std::shared_ptr<QLocalSocket> socket_;
+    QScopedPointer<StorageFrameworkClient> sf_client_;
+    ConnectionHelper connections_;
+    qint64 n_read_ = 0;
+    QFile file_;
+    QFutureWatcher<std::shared_ptr<Downloader>> future_watcher_;
+};
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-09-05 13:54:15 +0000
+++ tests/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -20,6 +20,11 @@
 )
 
 set(
+    RESTORE_HELPER
+    fake-restore-helper
+)
+
+set(
     BACKUP_HELPER_FAILURE
     fake-backup-helper-failure
 )
@@ -27,6 +32,7 @@
 set(KEEPER_TAR_CREATE_BIN ${CMAKE_BINARY_DIR}/src/tar/keeper-tar-create)
 set(KEEPER_HELPER_TEST_LOCATION ${CMAKE_BINARY_DIR}/tests/fakes/helpers-test.sh)
 set(BACKUP_HELPER_FAILURE_LOCATION ${CMAKE_BINARY_DIR}/tests/fakes/${BACKUP_HELPER_FAILURE})
+set(RESTORE_HELPER_TEST_LOCATION ${CMAKE_BINARY_DIR}/tests/fakes/${RESTORE_HELPER})
 
 add_definitions(
   -DCMAKE_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
 
=== modified file 'tests/com_canonical_keeper.py'
--- tests/com_canonical_keeper.py	2016-08-03 18:38:12 +0000
+++ tests/com_canonical_keeper.py	2016-11-17 00:23:33 +0000
@@ -1,3 +1,20 @@
+# 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:
+#   Charles Kerr <[e-mail]>
+
 import copy
 import dbus
 import dbus.service
 
=== modified file 'tests/fakes/CMakeLists.txt'
--- tests/fakes/CMakeLists.txt	2016-08-30 12:50:46 +0000
+++ tests/fakes/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -30,6 +30,16 @@
 )
 
 add_executable(
+    ${RESTORE_HELPER}
+    fake-restore-helper.cpp
+    restore-reader.cpp
+)
+target_link_libraries(
+    ${RESTORE_HELPER}
+    ${LINK_LIBS}
+)
+
+add_executable(
     ${BACKUP_HELPER_FAILURE}
     fake-backup-helper.cpp
 )
 
=== added file 'tests/fakes/fake-restore-helper.cpp'
--- tests/fakes/fake-restore-helper.cpp	1970-01-01 00:00:00 +0000
+++ tests/fakes/fake-restore-helper.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,101 @@
+/*
+ * 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:
+ *     Charles Kerr <[e-mail]>
+ */
+
+#include "fake-restore-helper.h"
+#include "restore-reader.h"
+
+#include <qdbus-stubs/dbus-types.h>
+#include <qdbus-stubs/keeper_helper_interface.h>
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+#include <QProcessEnvironment>
+#include <QLocalSocket>
+#include <QtGlobal>
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+
+void myMessageHandler(QtMsgType type, const QMessageLogContext &, const QString & msg)
+{
+    QString txt;
+    switch (type) {
+    case QtDebugMsg:
+        txt = QString("Debug: %1").arg(msg);
+        break;
+    case QtWarningMsg:
+        txt = QString("Warning: %1").arg(msg);
+    break;
+    case QtCriticalMsg:
+        txt = QString("Critical: %1").arg(msg);
+    break;
+    case QtFatalMsg:
+        txt = QString("Fatal: %1").arg(msg);
+        abort();
+    }
+    QFile outFile("/tmp/restore-helper-output");
+    outFile.open(QIODevice::WriteOnly | QIODevice::Append);
+    QTextStream ts(&outFile);
+    ts << txt << endl;
+}
+
+int
+main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+    qInstallMessageHandler(myMessageHandler);
+
+    // dump the inputs to stdout
+    qDebug() << "argc:" << argc;
+    for(int i=0; i<argc; ++i)
+        qDebug() << "argv[" << i << "] is" << argv[i];
+    const auto env = QProcessEnvironment::systemEnvironment();
+    for(const auto& key : env.keys())
+        qDebug() << "env" << qPrintable(key) << "is" << qPrintable(env.value(key));
+
+    qDebug() << "Retrieving connection";
+
+    // ask the service for a socket
+    auto conn = QDBusConnection::connectToBus(QDBusConnection::SessionBus, DBusTypes::KEEPER_SERVICE);
+    const auto object_path = QString::fromUtf8(DBusTypes::KEEPER_HELPER_PATH);
+    DBusInterfaceKeeperHelper helper_iface (DBusTypes::KEEPER_SERVICE, object_path, conn);
+
+    qDebug() << "Is valid:" << helper_iface.isValid();
+
+    auto fd_reply = helper_iface.StartRestore();
+    fd_reply.waitForFinished();
+    if (fd_reply.isError())
+    {
+        qFatal("Call to '%s.StartRestore() at '%s' call failed: %s",
+            DBusTypes::KEEPER_SERVICE,
+            qPrintable(object_path),
+            qPrintable(fd_reply.error().message())
+        );
+    }
+    const auto ufd = fd_reply.value();
+
+    // write the blob
+    const auto fd = ufd.fileDescriptor();
+    qDebug() << "The file descriptor obtained is: " << fd;
+    RestoreReader reader(fd, TEST_RESTORE_FILE_PATH);
+    return app.exec();
+}
 
=== added file 'tests/fakes/fake-restore-helper.h'
--- tests/fakes/fake-restore-helper.h	1970-01-01 00:00:00 +0000
+++ tests/fakes/fake-restore-helper.h	2016-11-17 00:23:33 +0000
@@ -0,0 +1,26 @@
+/*
+ * 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:
+ *     Charles Kerr <[e-mail]>
+ */
+
+#pragma once
+
+namespace
+{
+static char const TEST_RESTORE_FILE_PATH[] = "/tmp/test-restore-helper";
+
+}
 
=== added file 'tests/fakes/restore-reader.cpp'
--- tests/fakes/restore-reader.cpp	1970-01-01 00:00:00 +0000
+++ tests/fakes/restore-reader.cpp	2016-11-17 00:23:33 +0000
@@ -0,0 +1,81 @@
+/*
+ * 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 "restore-reader.h"
+
+#include <QCoreApplication>
+#include <QCryptographicHash>
+
+#include <unistd.h>
+
+//static constexpr int UPLOAD_BUFFER_MAX_ {1024*16};
+constexpr int UPLOAD_BUFFER_MAX_ = 16 * 1024;
+
+RestoreReader::RestoreReader(qint64 fd, QString const & file_path, QObject * parent)
+    : QObject(parent)
+    , file_(file_path)
+{
+    socket_.setSocketDescriptor(fd);
+    connect(&socket_, &QLocalSocket::readyRead, this, &RestoreReader::read_all);
+    connect(&socket_, &QLocalSocket::disconnected, this, &RestoreReader::finish);
+    if (!file_.open(QIODevice::WriteOnly | QIODevice::Truncate))
+    {
+        qFatal("Error opening file");
+    }
+
+    read_all();
+}
+
+void RestoreReader::read_all()
+{
+    qDebug() << Q_FUNC_INFO;
+
+    for (;;)
+    {
+        auto const chunk = socket_.readAll();
+        if (chunk.isEmpty())
+        {
+            qDebug() << "Failed to read from server" << socket_.errorString();
+            break;
+        }
+
+        n_bytes_read_ += chunk.size();
+        qDebug() << Q_FUNC_INFO << "n_bytes_read is now" << n_bytes_read_ << "after reading" << chunk.size();
+        if (file_.write(chunk) == -1)
+            qDebug() << Q_FUNC_INFO << "file write failed" << file_.errorString();
+
+        // THIS IS JUST FOR EXTRA DEBUG INFORMATION
+        QCryptographicHash hash(QCryptographicHash::Sha1);
+        hash.addData(chunk.data(), 100);
+        qInfo() << "Hash: bytes total: " << n_bytes_read_ << " " << hash.result().toHex();
+        // THIS IS JUST FOR EXTRA DEBUG INFORMATION
+    }
+}
+
+void RestoreReader::finish()
+{
+    qDebug() << "Finishing";
+    read_all();
+
+    file_.flush();
+    fsync(file_.handle());
+    file_.close();
+
+    QCoreApplication::exit();
+}
 
=== added file 'tests/fakes/restore-reader.h'
--- tests/fakes/restore-reader.h	1970-01-01 00:00:00 +0000
+++ tests/fakes/restore-reader.h	2016-11-17 00:23:33 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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 <QObject>
+#include <QFile>
+#include <QLocalSocket>
+
+class RestoreReader : public QObject
+{
+    Q_OBJECT
+public:
+    RestoreReader(qint64 fd, QString const & file_path, QObject * parent = nullptr);
+    ~RestoreReader() = default;
+
+private Q_SLOTS:
+    void read_all();
+    void finish();
+
+private:
+    void check_for_done();
+
+    QLocalSocket socket_;
+    qint64 n_bytes_read_ = 0;
+    QFile file_;
+};
 
=== modified file 'tests/integration/helpers/CMakeLists.txt'
--- tests/integration/helpers/CMakeLists.txt	2016-10-28 15:11:21 +0000
+++ tests/integration/helpers/CMakeLists.txt	2016-11-17 00:23:33 +0000
@@ -65,6 +65,10 @@
   FOLDER_BACKUP_EXEC
   ${KEEPER_HELPER_TEST_LOCATION}
 )
+set(
+  FOLDER_RESTORE_EXEC
+  ${RESTORE_HELPER_TEST_LOCATION}
+)
 configure_file(
   ${CMAKE_SOURCE_DIR}/data/${HELPER_REGISTRY_FILENAME}.in
   ${HELPERS_TEST}-registry.json
 
=== modified file 'tests/integration/helpers/helpers-test.cc'
--- tests/integration/helpers/helpers-test.cc	2016-11-02 14:01:23 +0000
+++ tests/integration/helpers/helpers-test.cc	2016-11-17 00:23:33 +0000
@@ -20,6 +20,7 @@
  */
 
 #include "test-helpers-base.h"
+#include "tests/fakes/fake-restore-helper.h"
 
 class TestHelpers: public TestHelpersBase
 {
@@ -32,30 +33,31 @@
     }
 };
 
-TEST_F(TestHelpers, StartHelper)
-{
-    // starts the services, including keeper-service
-    start_tasks();
-
-    BackupHelper helper("com.test.multiple_first_1.2.3");
-
-    QSignalSpy spy(&helper, &BackupHelper::state_changed);
-
-    helper.start({"/bin/ls","/tmp"});
-
-    // wait for 2 signals.
-    // One for started, another one when the helper stops
-    WAIT_FOR_SIGNALS(spy, 2, 15000);
-
-    ASSERT_EQ(spy.count(), 2);
-    QList<QVariant> arguments = spy.takeFirst();
-    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::STARTED);
-    arguments = spy.takeFirst();
-    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::COMPLETE);
-}
+//TEST_F(TestHelpers, StartHelper)
+//{
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    BackupHelper helper("com.test.multiple_first_1.2.3");
+//
+//    QSignalSpy spy(&helper, &BackupHelper::state_changed);
+//
+//    helper.start({"/bin/ls","/tmp"});
+//
+//    // wait for 2 signals.
+//    // One for started, another one when the helper stops
+//    WAIT_FOR_SIGNALS(spy, 2, 15000);
+//
+//    ASSERT_EQ(spy.count(), 2);
+//    QList<QVariant> arguments = spy.takeFirst();
+//    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::STARTED);
+//    arguments = spy.takeFirst();
+//    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::COMPLETE);
+//}
 
 TEST_F(TestHelpers, StartFullTest)
 {
+    system("rm -f /tmp/restore-helper-output");
     XdgUserDirsSandbox tmp_dir;
 
     // starts the services, including keeper-service
@@ -82,7 +84,7 @@
     qDebug() << "USER DIR:" << user_dir;
 
     // fill something in the music dir
-    FileUtils::fillTemporaryDirectory(user_dir, qrand() % 100);
+    FileUtils::fillTemporaryDirectory(user_dir, qrand() % 10);
 
     // search for the user folder uuid
     auto user_folder_uuid = get_uuid_for_xdg_folder_path(user_dir, choices.value());
@@ -101,7 +103,7 @@
     qDebug() << "USER DIR 2:" << user_dir_2;
 
     // fill something in the music dir
-    FileUtils::fillTemporaryDirectory(user_dir_2, qrand() % 100);
+    FileUtils::fillTemporaryDirectory(user_dir_2, qrand() % 10);
 
     // search for the user folder uuid
     auto user_folder_uuid_2 = get_uuid_for_xdg_folder_path(user_dir_2, choices.value());
@@ -140,164 +142,197 @@
 
     // finally check that we have a valid manifest file.
     EXPECT_TRUE(check_manifest_file(backup_items));
-}
-
-TEST_F(TestHelpers, StartFullTestCancelling)
-{
-    XdgUserDirsSandbox tmp_dir;
-
-    // starts the services, including keeper-service
-    start_tasks();
-
-    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
-                                                            DBusTypes::KEEPER_SERVICE,
-                                                            DBusTypes::KEEPER_USER_PATH,
-                                                            dbus_test_runner.sessionConnection()
-                                                        ) );
-
-    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
-
-    // ask for a list of backup choices
-    QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");
-    EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
-
-    QString user_option = QStringLiteral("XDG_MUSIC_DIR");
-
-    auto user_dir = qgetenv(user_option.toLatin1().data());
-    ASSERT_FALSE(user_dir.isEmpty());
-    qDebug() << "USER DIR:" << user_dir;
-
-    // fill something in the music dir
-    FileUtils::fillTemporaryDirectory(user_dir, qrand() % 1000);
-
-    // search for the user folder uuid
-    auto user_folder_uuid = get_uuid_for_xdg_folder_path(user_dir, choices.value());
-    ASSERT_FALSE(user_folder_uuid.isEmpty());
-    qDebug() << "User folder UUID is:" << user_folder_uuid;
-
-    QString user_option_2 = QStringLiteral("XDG_VIDEOS_DIR");
-
-    auto user_dir_2 = qgetenv(user_option_2.toLatin1().data());
-    ASSERT_FALSE(user_dir_2.isEmpty());
-    qDebug() << "USER DIR 2:" << user_dir_2;
-
-    // fill something in the music dir
-    FileUtils::fillTemporaryDirectory(user_dir_2, qrand() % 1000);
-
-    // search for the user folder uuid
-    auto user_folder_uuid_2 = get_uuid_for_xdg_folder_path(user_dir_2, choices.value());
-    ASSERT_FALSE(user_folder_uuid_2.isEmpty());
-    qDebug() << "User folder 2 UUID is:" << user_folder_uuid_2;
-
-    QSharedPointer<DBusPropertiesInterface> properties_interface(new DBusPropertiesInterface(
-                                                            DBusTypes::KEEPER_SERVICE,
-                                                            DBusTypes::KEEPER_USER_PATH,
-                                                            dbus_test_runner.sessionConnection()
-                                                        ) );
-
-    ASSERT_TRUE(properties_interface->isValid()) << qPrintable(QDBusConnection::sessionBus().lastError().message());
-
-    QSignalSpy spy(properties_interface.data(),&DBusPropertiesInterface::PropertiesChanged);
-
-    // Now we know the music folder uuid, let's start the backup for it.
-    QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{user_folder_uuid, user_folder_uuid_2});
-    ASSERT_TRUE(backup_reply.isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
-
-    EXPECT_TRUE(cancel_first_task_at_percentage(spy, 0.05, user_iface));
-
-    // wait until all the tasks have the action state "complete"
-    // this one uses pooling so it should just call Get once
-    EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid, user_folder_uuid_2}, "cancelled", user_iface));
-
-    // check that we have no files in storage framework
-    EXPECT_EQ(0, StorageFrameworkLocalUtils::check_storage_framework_nb_files());
-}
-
-TEST_F(TestHelpers, CheckBadUUIDS)
-{
-    XdgUserDirsSandbox tmp_dir;
-
-    // starts the services, including keeper-service
-    start_tasks();
-
-    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
-                                                            DBusTypes::KEEPER_SERVICE,
-                                                            DBusTypes::KEEPER_USER_PATH,
-                                                            dbus_test_runner.sessionConnection()
-                                                        ) );
-
-    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
-
-    // Now we know the music folder uuid, let's start the backup for it.
-    QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{"bad_uuid_1", "bad_uuid_2"});
-
-    ASSERT_FALSE(backup_reply.isValid());
-
-    // check the error message
-    // the uuids are not printed always in the same order
-    QString error_message = dbus_test_runner.sessionConnection().lastError().message();
-    EXPECT_TRUE(error_message.startsWith("unhandled uuids: "));
-    EXPECT_TRUE(error_message.contains("bad_uuid_1"));
-    EXPECT_TRUE(error_message.contains("bad_uuid_2"));
-}
-
-TEST_F(TestHelpers, SimplyCheckThatTheSecondDBusInterfaceIsFine)
-{
-    XdgUserDirsSandbox tmp_dir;
-
-    // starts the services, including keeper-service
-    start_tasks();
-
-    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
-                                                            DBusTypes::KEEPER_SERVICE,
-                                                            DBusTypes::KEEPER_USER_PATH,
-                                                            dbus_test_runner.sessionConnection()
-                                                        ) );
-
-    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
-
-}
-
-TEST_F(TestHelpers, BadHelperPath)
-{
-    // starts the services, including keeper-service
-    start_tasks();
-
-    BackupHelper helper("com.bar_foo_8432.13.1");
-
-    QSignalSpy spy(&helper, &BackupHelper::state_changed);
-    QStringList urls;
-    urls << "blah" << "/tmp";
-    helper.start(urls);
-
-    WAIT_FOR_SIGNALS(spy, 1, Helper::MAX_UAL_WAIT_TIME + 1000);
-
-    ASSERT_EQ(spy.count(), 1);
-    QList<QVariant> arguments = spy.takeFirst();
-    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::FAILED);
-}
-
-TEST_F(TestHelpers, Inactivity)
-{
-    // starts the services, including keeper-service
-    start_tasks();
-
-    BackupHelper helper("com.bar_foo_8432.13.1");
-
-    QSignalSpy spy(&helper, &BackupHelper::state_changed);
-    QStringList urls;
-    urls << TEST_INACTIVE_HELPER << "/tmp";
-    helper.start(urls);
-
-    // wait 15 seconds at most.
-    // the inactive helper sleeps for 100 seconds so
-    // if we get the 2 signals it means it was stopped due to inactivity
-    // We can also check at the end for the state, which should be CANCELLED
-    WAIT_FOR_SIGNALS(spy, 2, BackupHelper::MAX_INACTIVITY_TIME + 2000);
-
-    ASSERT_EQ(spy.count(), 2);
-    QList<QVariant> arguments = spy.takeFirst();
-    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::STARTED);
-    arguments = spy.takeFirst();
-    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::CANCELLED);
-}
+
+    QDBusPendingReply<QVariantDictMap> restore_choices_reply = user_iface->call("GetRestoreChoices");
+    restore_choices_reply.waitForFinished();
+    EXPECT_TRUE(restore_choices_reply.isValid()) << qPrintable(choices.error().message());
+
+    const auto restore_choices = restore_choices_reply.value();
+    EXPECT_EQ(2, restore_choices.size());
+
+    // check that we have the first uuid that we did the backup
+    const auto iter_restore = restore_choices.find(user_folder_uuid);
+    EXPECT_NE(iter_restore, restore_choices.end());
+    EXPECT_EQ(user_folder_uuid, iter_restore.key());
+
+    // ask to restore that uuid
+    QDBusPendingReply<void> restore_reply = user_iface->call("StartRestore", QStringList{iter_restore.key()});
+    restore_reply.waitForFinished();
+    ASSERT_TRUE(restore_reply.isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
+
+    // waits until all tasks are complete, recording PropertiesChanged signals
+    // and checks all the recorded values
+    EXPECT_TRUE(capture_and_check_state_until_all_tasks_complete(spy, {iter_restore.key()}, "complete"));
+
+    // verify that the file that the fake restore helper creates is one of the ones in storage framework
+    QString storage_framework_file_path;
+    EXPECT_TRUE(StorageFrameworkLocalUtils::get_storage_frameowork_file_equal_to(TEST_RESTORE_FILE_PATH, storage_framework_file_path));
+
+    // Finally check that the storage framework file that matched is the right one
+    // Keeper uses the display name plus .keeper extension for the files it creates
+    QFileInfo sf_file_info(storage_framework_file_path);
+    EXPECT_EQ(sf_file_info.fileName(), QStringLiteral("%1.keeper").arg(get_display_name_for_xdg_folder_path(user_dir, choices.value())));
+
+    qDebug() << "-----------------------------------------------------";
+    system("cat /tmp/restore-helper-output");
+}
+
+//TEST_F(TestHelpers, StartFullTestCancelling)
+//{
+//    XdgUserDirsSandbox tmp_dir;
+//
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
+//                                                            DBusTypes::KEEPER_SERVICE,
+//                                                            DBusTypes::KEEPER_USER_PATH,
+//                                                            dbus_test_runner.sessionConnection()
+//                                                        ) );
+//
+//    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
+//
+//    // ask for a list of backup choices
+//    QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");
+//    EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
+//
+//    QString user_option = QStringLiteral("XDG_MUSIC_DIR");
+//
+//    auto user_dir = qgetenv(user_option.toLatin1().data());
+//    ASSERT_FALSE(user_dir.isEmpty());
+//    qDebug() << "USER DIR:" << user_dir;
+//
+//    // fill something in the music dir
+//    FileUtils::fillTemporaryDirectory(user_dir, qrand() % 1000);
+//
+//    // search for the user folder uuid
+//    auto user_folder_uuid = get_uuid_for_xdg_folder_path(user_dir, choices.value());
+//    ASSERT_FALSE(user_folder_uuid.isEmpty());
+//    qDebug() << "User folder UUID is:" << user_folder_uuid;
+//
+//    QString user_option_2 = QStringLiteral("XDG_VIDEOS_DIR");
+//
+//    auto user_dir_2 = qgetenv(user_option_2.toLatin1().data());
+//    ASSERT_FALSE(user_dir_2.isEmpty());
+//    qDebug() << "USER DIR 2:" << user_dir_2;
+//
+//    // fill something in the music dir
+//    FileUtils::fillTemporaryDirectory(user_dir_2, qrand() % 1000);
+//
+//    // search for the user folder uuid
+//    auto user_folder_uuid_2 = get_uuid_for_xdg_folder_path(user_dir_2, choices.value());
+//    ASSERT_FALSE(user_folder_uuid_2.isEmpty());
+//    qDebug() << "User folder 2 UUID is:" << user_folder_uuid_2;
+//
+//    QSharedPointer<DBusPropertiesInterface> properties_interface(new DBusPropertiesInterface(
+//                                                            DBusTypes::KEEPER_SERVICE,
+//                                                            DBusTypes::KEEPER_USER_PATH,
+//                                                            dbus_test_runner.sessionConnection()
+//                                                        ) );
+//
+//    ASSERT_TRUE(properties_interface->isValid()) << qPrintable(QDBusConnection::sessionBus().lastError().message());
+//
+//    QSignalSpy spy(properties_interface.data(),&DBusPropertiesInterface::PropertiesChanged);
+//
+//    // Now we know the music folder uuid, let's start the backup for it.
+//    QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{user_folder_uuid, user_folder_uuid_2});
+//    ASSERT_TRUE(backup_reply.isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
+//
+//    EXPECT_TRUE(cancel_first_task_at_percentage(spy, 0.05, user_iface));
+//
+//    // wait until all the tasks have the action state "complete"
+//    // this one uses pooling so it should just call Get once
+//    EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid, user_folder_uuid_2}, "cancelled", user_iface));
+//
+//    // check that we have no files in storage framework
+//    EXPECT_EQ(0, StorageFrameworkLocalUtils::check_storage_framework_nb_files());
+//}
+//
+//TEST_F(TestHelpers, CheckBadUUIDS)
+//{
+//    XdgUserDirsSandbox tmp_dir;
+//
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
+//                                                            DBusTypes::KEEPER_SERVICE,
+//                                                            DBusTypes::KEEPER_USER_PATH,
+//                                                            dbus_test_runner.sessionConnection()
+//                                                        ) );
+//
+//    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
+//
+//    // Now we know the music folder uuid, let's start the backup for it.
+//    QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{"bad_uuid_1", "bad_uuid_2"});
+//
+//    ASSERT_FALSE(backup_reply.isValid());
+//
+//    // check the error message
+//    // the uuids are not printed always in the same order
+//    QString error_message = dbus_test_runner.sessionConnection().lastError().message();
+//    EXPECT_TRUE(error_message.startsWith("unhandled uuids: "));
+//    EXPECT_TRUE(error_message.contains("bad_uuid_1"));
+//    EXPECT_TRUE(error_message.contains("bad_uuid_2"));
+//}
+//
+//TEST_F(TestHelpers, SimplyCheckThatTheSecondDBusInterfaceIsFine)
+//{
+//    XdgUserDirsSandbox tmp_dir;
+//
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    QSharedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
+//                                                            DBusTypes::KEEPER_SERVICE,
+//                                                            DBusTypes::KEEPER_USER_PATH,
+//                                                            dbus_test_runner.sessionConnection()
+//                                                        ) );
+//
+//    ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
+//
+//}
+//
+//TEST_F(TestHelpers, BadHelperPath)
+//{
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    BackupHelper helper("com.bar_foo_8432.13.1");
+//
+//    QSignalSpy spy(&helper, &BackupHelper::state_changed);
+//    QStringList urls;
+//    urls << "blah" << "/tmp";
+//    helper.start(urls);
+//
+//    WAIT_FOR_SIGNALS(spy, 1, Helper::MAX_UAL_WAIT_TIME + 1000);
+//
+//    ASSERT_EQ(spy.count(), 1);
+//    QList<QVariant> arguments = spy.takeFirst();
+//    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::FAILED);
+//}
+//
+//TEST_F(TestHelpers, Inactivity)
+//{
+//    // starts the services, including keeper-service
+//    start_tasks();
+//
+//    BackupHelper helper("com.bar_foo_8432.13.1");
+//
+//    QSignalSpy spy(&helper, &BackupHelper::state_changed);
+//    QStringList urls;
+//    urls << TEST_INACTIVE_HELPER << "/tmp";
+//    helper.start(urls);
+//
+//    // wait 15 seconds at most.
+//    // the inactive helper sleeps for 100 seconds so
+//    // if we get the 2 signals it means it was stopped due to inactivity
+//    // We can also check at the end for the state, which should be CANCELLED
+//    WAIT_FOR_SIGNALS(spy, 2, BackupHelper::MAX_INACTIVITY_TIME + 2000);
+//
+//    ASSERT_EQ(spy.count(), 2);
+//    QList<QVariant> arguments = spy.takeFirst();
+//    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::STARTED);
+//    arguments = spy.takeFirst();
+//    EXPECT_EQ(qvariant_cast<Helper::State>(arguments.at(0)), Helper::State::CANCELLED);
+//}
 
=== modified file 'tests/integration/helpers/test-helpers-base.cpp'
--- tests/integration/helpers/test-helpers-base.cpp	2016-11-03 08:58:51 +0000
+++ tests/integration/helpers/test-helpers-base.cpp	2016-11-17 00:23:33 +0000
@@ -179,15 +179,19 @@
     {
         return previous == "saving" || previous == "queued";
     }
+    else if (current == "restoring")
+    {
+        return previous == "restoring" || previous == "queued";
+    }
     else if (current == "finishing")
     {
-        return previous == "finishing" || previous == "saving";
+        return previous == "finishing" || previous == "saving" || previous == "restoring";
     }
     else if (current == "complete")
     {
         // we may pass from "saving" to "complete" if we don't have enough time
         // to emit the "finishing" state change
-        return previous == "complete" || previous == "finishing" || previous == "saving";
+        return previous == "complete" || previous == "finishing" || previous == "saving" || previous == "restoring";
     }
     else if (current == "failed")
     {
@@ -704,7 +708,7 @@
         return false;
     }
 
-    QSharedPointer<StorageFrameworkClient> sf_client(new StorageFrameworkClient);
+    QSharedPointer<StorageFrameworkClient> sf_client(new StorageFrameworkClient, [](StorageFrameworkClient* sf){sf->deleteLater();});
     Manifest manifest_read(sf_client, dir_name);
     QSignalSpy spy_read(&manifest_read, &Manifest::finished);
 
@@ -716,6 +720,7 @@
     if (!spy_read.count())
     {
         qWarning() << "Failed reading manifest file";
+        sf_client.reset();
         return false;
     }
 
 
=== modified file 'tests/unit/manifest/manifest-test.cpp'
--- tests/unit/manifest/manifest-test.cpp	2016-10-06 14:53:44 +0000
+++ tests/unit/manifest/manifest-test.cpp	2016-11-17 00:23:33 +0000
@@ -78,7 +78,7 @@
 
     g_setenv("XDG_DATA_HOME", tmp_dir.path().toLatin1().data(), true);
 
-    QSharedPointer<StorageFrameworkClient> sf_client(new StorageFrameworkClient);
+    QSharedPointer<StorageFrameworkClient> sf_client(new StorageFrameworkClient, [](StorageFrameworkClient* sf){sf->deleteLater();});
     Manifest manifest(sf_client, test_dir);
 
     auto objects_to_test = 10;
 
=== modified file 'tests/unit/storage-framework/create-uploader-test.cpp'
--- tests/unit/storage-framework/create-uploader-test.cpp	2016-11-02 11:31:09 +0000
+++ tests/unit/storage-framework/create-uploader-test.cpp	2016-11-17 00:23:33 +0000
@@ -86,7 +86,7 @@
     // create a downloader
     auto downloader_fut = sf_client.get_new_downloader(test_dir, test_file_name);
     {
-        QFutureWatcher<sf::Downloader::SPtr> w;
+        QFutureWatcher<std::shared_ptr<Downloader>> w;
         QSignalSpy spy(&w, &decltype(w)::finished);
         w.setFuture(downloader_fut);
         assert(spy.wait());
@@ -107,14 +107,13 @@
 
     EXPECT_EQ(downloader_content, test_content);
 
-    auto finish_downloader_fut = downloader->finish_download();
+    QSignalSpy spy_downloader(downloader.get(), &Downloader::download_finished);
+    downloader->finish();
+    if (!spy_downloader.count())
     {
-        QFutureWatcher<void> w;
-        QSignalSpy spy(&w, &decltype(w)::finished);
-        w.setFuture(finish_downloader_fut);
-        assert(spy.wait());
-        ASSERT_EQ(spy.count(), 1);
+        spy_downloader.wait();
     }
+    EXPECT_EQ(1, spy_downloader.count());
 
     // get another uploader
     QString test_file_name_2 = QStringLiteral("test_file2");
 
=== modified file 'tests/utils/file-utils.cpp'
--- tests/utils/file-utils.cpp	2016-11-02 10:43:30 +0000
+++ tests/utils/file-utils.cpp	2016-11-17 00:23:33 +0000
@@ -198,8 +198,10 @@
         qWarning() << "File to compare:" << info2.absoluteFilePath() << "does not exist";
         return false;
     }
+    qDebug() << "File 1 size: " << info1.size() << info1.absoluteFilePath();
+    qDebug() << "File 2 size: " << info2.size() << info2.absoluteFilePath();
     auto checksum1 = calculate_checksum(filePath1, QCryptographicHash::Md5);
-    auto checksum2 = calculate_checksum(filePath1, QCryptographicHash::Md5);
+    auto checksum2 = calculate_checksum(filePath2, QCryptographicHash::Md5);
     if (checksum1 != checksum2)
     {
         qWarning() << "Checksum for file:" << filePath1 << "differ";
 
=== modified file 'tests/utils/storage-framework-local.cpp'
--- tests/utils/storage-framework-local.cpp	2016-10-28 15:11:21 +0000
+++ tests/utils/storage-framework-local.cpp	2016-11-17 00:23:33 +0000
@@ -170,4 +170,38 @@
             : "";
 }
 
+bool get_storage_frameowork_file_equal_to(QString const & file_path, QString & path)
+{
+    auto const backups = get_storage_framework_files();
+    for (auto const& backup : backups)
+    {
+        auto const backup_filename = backup.absoluteFilePath();
+        if (FileUtils::compareFiles(file_path, backup_filename))
+        {
+            path = backup_filename;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool get_storage_frameowork_file_equal_in_size_to(QString const & file_path, QString & path)
+{
+    auto const backups = get_storage_framework_files();
+    for (auto const& backup : backups)
+    {
+        auto const backup_filename = backup.absoluteFilePath();
+        QFileInfo info1(backup_filename);
+        QFileInfo info2(file_path);
+        qDebug() << "File 1 size = " << info1.size();
+        qDebug() << "File 2 size = " << info2.size();
+        if (info1.size() == info2.size())
+        {
+            path = backup_filename;
+            return true;
+        }
+    }
+    return false;
+}
+
 } // namespace StorageFrameworkLocalUtils
 
=== modified file 'tests/utils/storage-framework-local.h'
--- tests/utils/storage-framework-local.h	2016-10-28 15:11:21 +0000
+++ tests/utils/storage-framework-local.h	2016-11-17 00:23:33 +0000
@@ -41,4 +41,8 @@
     QFileInfoList get_storage_framework_files();
 
     QString get_storage_framework_dir_name();
+
+    bool get_storage_frameowork_file_equal_to(QString const & file_path, QString & path);
+
+    bool get_storage_frameowork_file_equal_in_size_to(QString const & file_path, QString & path);
 }