Keeper

Merge lp:~xavi-garcia-mena/keeper/sf-errors-dbus-interface into lp:keeper/devel

  1. sf-errors-dbus-interface
  2. Merge into devel
Proposed by Xavi Garcia
Status: Merged
Merged at revision: 127
Proposed branch: lp:~xavi-garcia-mena/keeper/sf-errors-dbus-interface
Merge into: lp:keeper/devel
Diff against target: 2685 lines (+930/-444)
40 files modified
include/client/client.h (+5/-4)
include/client/keeper-errors.h (+18/-11)
include/client/keeper-items.h (+78/-0)
include/helper/helper.h (+1/-1)
src/cli/command-line-client-view.cpp (+34/-16)
src/cli/command-line-client-view.h (+3/-3)
src/cli/command-line-client.cpp (+69/-82)
src/cli/command-line-client.h (+5/-3)
src/client/CMakeLists.txt (+3/-0)
src/client/client.cpp (+65/-46)
src/client/keeper-errors.cpp (+9/-9)
src/client/keeper-items.cpp (+212/-0)
src/helper/backup-helper.cpp (+6/-6)
src/helper/helper.cpp (+1/-1)
src/helper/restore-helper.cpp (+5/-5)
src/qdbus-stubs/CMakeLists.txt (+5/-4)
src/qdbus-stubs/com.canonical.keeper.User.xml (+3/-3)
src/qdbus-stubs/dbus-types.h (+5/-2)
src/service/backup-choices.cpp (+1/-1)
src/service/keeper-task-backup.cpp (+11/-5)
src/service/keeper-task-restore.cpp (+9/-3)
src/service/keeper-task.cpp (+6/-6)
src/service/keeper-task.h (+3/-2)
src/service/keeper-user.cpp (+3/-3)
src/service/keeper-user.h (+4/-4)
src/service/keeper.cpp (+103/-58)
src/service/keeper.h (+3/-3)
src/service/metadata-provider.h (+2/-1)
src/service/private/keeper-task_p.h (+2/-2)
src/service/restore-choices.cpp (+3/-3)
src/service/task-manager.cpp (+34/-6)
src/service/task-manager.h (+3/-2)
src/storage-framework/storage_framework_client.cpp (+57/-1)
src/storage-framework/storage_framework_client.h (+5/-0)
tests/dbusmock/keeper-template-test.cpp (+111/-102)
tests/integration/helpers/helpers-test-failure.cpp (+10/-10)
tests/integration/helpers/helpers-test.cc (+5/-5)
tests/integration/helpers/restore-test.cpp (+1/-1)
tests/integration/helpers/test-helpers-base.cpp (+22/-25)
tests/integration/helpers/test-helpers-base.h (+5/-5)
To merge this branch: bzr merge lp:~xavi-garcia-mena/keeper/sf-errors-dbus-interface
Reviewer Review Type Date Requested Status
unity-api-1-bot continuous-integration Needs Fixing
Xavi Garcia Pending
Review via email: mp+313721@code.launchpad.net

This proposal supersedes a proposal from 2016-12-21.

Commit message

Just for testing build

Description of the change

Just for testing build

To post a comment you must log in.
Revision history for this message
unity-api-1-bot (unity-api-1-bot) wrote : Posted in a previous version of this proposal

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

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

review: Needs Fixing (continuous-integration)
Revision history for this message
unity-api-1-bot (unity-api-1-bot) wrote :

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

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

review: Needs Fixing (continuous-integration)
lp:~xavi-garcia-mena/keeper/sf-errors-dbus-interface updated
127. By Xavi Garcia

conflicts resolved

Revision history for this message
unity-api-1-bot (unity-api-1-bot) wrote :

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

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

review: Needs Fixing (continuous-integration)
lp:~xavi-garcia-mena/keeper/sf-errors-dbus-interface updated
128. By Xavi Garcia

Removed metadata_error signal, signature of dbus is internally again QVariantDictMap, returning error as additional dbus argument

129. By Xavi Garcia

KeeperError as Error and error codes changed

130. By Xavi Garcia

Fixed CMakeLists.txt

Revision history for this message
unity-api-1-bot (unity-api-1-bot) wrote :

FAILED: Continuous integration, rev:130
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/161/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1297/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1304
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1083
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1083/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1083/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1083
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1083/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1083/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1083
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1083/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1083/console

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

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'include/client/client.h'
--- include/client/client.h 2016-12-14 11:00:21 +0000
+++ include/client/client.h 2016-12-22 14:35:27 +0000
@@ -25,6 +25,7 @@
25#include <QScopedPointer>25#include <QScopedPointer>
26#include <QStringList>26#include <QStringList>
27#include <QVariant>27#include <QVariant>
28#include "keeper-items.h"
2829
29struct KeeperClientPrivate;30struct KeeperClientPrivate;
3031
@@ -62,12 +63,12 @@
6263
63// C++64// C++
64public:65public:
65 QMap<QString, QVariantMap> getBackupChoices() const;66 keeper::KeeperItemsMap getBackupChoices(keeper::Error & error) const;
66 QMap<QString, QVariantMap> getRestoreChoices() const;67 keeper::KeeperItemsMap getRestoreChoices(keeper::Error & error) const;
67 void startBackup(QStringList const& uuids) const;68 void startBackup(QStringList const& uuids) const;
68 void startRestore(QStringList const& uuids) const;69 void startRestore(QStringList const& uuids) const;
6970
70 QMap<QString, QVariantMap> getState() const;71 keeper::KeeperItemsMap getState() const;
7172
72Q_SIGNALS:73Q_SIGNALS:
73 void statusChanged();74 void statusChanged();
@@ -75,7 +76,7 @@
75 void readyToBackupChanged();76 void readyToBackupChanged();
76 void backupBusyChanged();77 void backupBusyChanged();
7778
78 void taskStatusChanged(QString const & displayName, QString const & status, double percentage, keeper::KeeperError error);79 void taskStatusChanged(QString const & displayName, QString const & status, double percentage, keeper::Error error);
79 void finished();80 void finished();
8081
81private Q_SLOTS:82private Q_SLOTS:
8283
=== modified file 'include/client/keeper-errors.h'
--- include/client/keeper-errors.h 2016-12-21 08:36:57 +0000
+++ include/client/keeper-errors.h 2016-12-22 14:35:27 +0000
@@ -25,25 +25,32 @@
25namespace keeper25namespace keeper
26{26{
2727
28enum class KeeperError28enum class Error
29{29{
30 OK,30 OK,
31 ERROR_UNKNOWN,31 UNKNOWN,
32 HELPER_READ_ERROR,32 HELPER_READ,
33 HELPER_WRITE_ERROR,33 HELPER_WRITE,
34 HELPER_INACTIVITY_DETECTED,34 HELPER_INACTIVITY_DETECTED,
35 HELPER_SOCKET_ERROR,35 HELPER_SOCKET,
36 HELPER_START_TIMEOUT,36 HELPER_START_TIMEOUT,
37 NO_HELPER_INFORMATION_IN_REGISTRY,37 NO_HELPER_INFORMATION_IN_REGISTRY,
38 HELPER_BAD_URL,38 HELPER_BAD_URL,
39 MANIFEST_STORAGE_ERROR,39 MANIFEST_STORAGE,
40 COMMITTING_DATA_ERROR40 COMMITTING_DATA,
41
42 CREATING_REMOTE_DIR,
43 CREATING_REMOTE_FILE,
44 READING_REMOTE_FILE,
45 REMOTE_DIR_NOT_EXISTS,
46 NO_REMOTE_ACCOUNTS,
47 NO_REMOTE_ROOTS
41};48};
4249
43KeeperError convertFromDBusVariant(const QVariant & value, bool *conversion_ok = nullptr);50Error convert_from_dbus_variant(const QVariant & value, bool *conversion_ok = nullptr);
44} // namespace keeper51} // namespace keeper
4552
46QDBusArgument &operator<<(QDBusArgument &argument, keeper::KeeperError value);53QDBusArgument &operator<<(QDBusArgument &argument, keeper::Error value);
47const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::KeeperError &val);54const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::Error &val);
4855
49Q_DECLARE_METATYPE(keeper::KeeperError)56Q_DECLARE_METATYPE(keeper::Error)
5057
=== added file 'include/client/keeper-items.h'
--- include/client/keeper-items.h 1970-01-01 00:00:00 +0000
+++ include/client/keeper-items.h 2016-12-22 14:35:27 +0000
@@ -0,0 +1,78 @@
1/*
2 * Copyright (C) 2016 Canonical, Ltd.
3 *
4 * This program is free software: you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 3, as published
6 * by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranties of
10 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
11 * PURPOSE. See the GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Authors:
17 * Xavi Garcia Mena <xavi.garcia.mena@canonical.com>
18 */
19
20#pragma once
21
22#include "client/keeper-errors.h"
23
24#include <QDBusArgument>
25#include <QObject>
26#include <QScopedPointer>
27
28typedef QMap<QString, QVariantMap> QVariantDictMap;
29
30namespace keeper
31{
32
33class KeeperItem : public QVariantMap
34{
35public:
36 KeeperItem();
37 ~KeeperItem();
38 explicit KeeperItem(QVariantMap const & values);
39
40 // methods created for convenience
41 bool has_property(QString const & property) const;
42 QVariant get_property_value(QString const & property) const;
43
44 // checks that the item is valid
45 bool is_valid() const;
46
47 // predefined properties
48 QString get_type(bool *valid = nullptr) const;
49 QString get_display_name(bool *valid = nullptr) const;
50 QString get_dir_name(bool *valid = nullptr) const;
51 QString get_status(bool *valid = nullptr) const;
52 double get_percent_done(bool *valid = nullptr) const;
53 keeper::Error get_error(bool *valid = nullptr) const;
54
55 // d-bus
56 static void registerMetaType();
57};
58
59class KeeperItemsMap : public QMap<QString, KeeperItem>
60{
61public:
62 KeeperItemsMap();
63 ~KeeperItemsMap();
64 explicit KeeperItemsMap(Error error);
65
66 QStringList get_uuids() const;
67
68 // d-bus
69 static void registerMetaType();
70
71private:
72 Error error_ = Error::OK;
73};
74
75} // namespace keeper
76
77Q_DECLARE_METATYPE(keeper::KeeperItem)
78Q_DECLARE_METATYPE(keeper::KeeperItemsMap)
079
=== modified file 'include/helper/helper.h'
--- include/helper/helper.h 2016-12-14 11:00:21 +0000
+++ include/helper/helper.h 2016-12-22 14:35:27 +0000
@@ -70,7 +70,7 @@
70Q_SIGNALS:70Q_SIGNALS:
71 void state_changed(Helper::State);71 void state_changed(Helper::State);
72 void percent_done_changed(float);72 void percent_done_changed(float);
73 void error(keeper::KeeperError error);73 void error(keeper::Error error);
7474
75protected:75protected:
76 Helper(QString const & appid, const clock_func& clock=default_clock, QObject *parent=nullptr);76 Helper(QString const & appid, const clock_func& clock=default_clock, QObject *parent=nullptr);
7777
=== modified file 'src/cli/command-line-client-view.cpp'
--- src/cli/command-line-client-view.cpp 2016-12-21 08:36:57 +0000
+++ src/cli/command-line-client-view.cpp 2016-12-22 14:35:27 +0000
@@ -48,7 +48,7 @@
4848
49void CommandLineClientView::add_task(QString const & display_name, QString const & initial_status, double initial_percentage)49void CommandLineClientView::add_task(QString const & display_name, QString const & initial_status, double initial_percentage)
50{50{
51 tasks_strings_[display_name] = get_task_string(display_name, initial_status, initial_percentage, keeper::KeeperError::OK);51 tasks_strings_[display_name] = get_task_string(display_name, initial_status, initial_percentage, keeper::Error::OK);
52 // TODO see if we can do this in a better way52 // TODO see if we can do this in a better way
53 // We add a line per each backup task53 // We add a line per each backup task
54 std::cout << std::endl;54 std::cout << std::endl;
@@ -112,58 +112,76 @@
112 return ret;112 return ret;
113}113}
114114
115QString CommandLineClientView::get_task_string(QString const & displayName, QString const & status, double percentage, keeper::KeeperError error)115QString CommandLineClientView::get_task_string(QString const & displayName, QString const & status, double percentage, keeper::Error error)
116{116{
117117
118 if (error == keeper::KeeperError::OK)118 if (error == keeper::Error::OK)
119 return QStringLiteral("%1 %2 % %3").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15);119 return QStringLiteral("%1 %2 % %3").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15);
120 else120 else
121 return QStringLiteral("%1 %2 % %3 %4").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15).arg(get_error_string(error));121 return QStringLiteral("%1 %2 % %3 %4").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15).arg(get_error_string(error));
122}122}
123123
124QString CommandLineClientView::get_error_string(keeper::KeeperError error)124QString CommandLineClientView::get_error_string(keeper::Error error)
125{125{
126 QString ret;126 QString ret;
127 switch(error)127 switch(error)
128 {128 {
129 case keeper::KeeperError::ERROR_UNKNOWN:129 case keeper::Error::UNKNOWN:
130 ret = QStringLiteral("Unknown error");130 ret = QStringLiteral("Unknown error");
131 break;131 break;
132 case keeper::KeeperError::HELPER_BAD_URL:132 case keeper::Error::HELPER_BAD_URL:
133 ret = QStringLiteral("Bad URL for keeper helper");133 ret = QStringLiteral("Bad URL for keeper helper");
134 break;134 break;
135 case keeper::KeeperError::HELPER_INACTIVITY_DETECTED:135 case keeper::Error::HELPER_INACTIVITY_DETECTED:
136 ret = QStringLiteral("Inactivity detected in task");136 ret = QStringLiteral("Inactivity detected in task");
137 break;137 break;
138 case keeper::KeeperError::HELPER_START_TIMEOUT:138 case keeper::Error::HELPER_START_TIMEOUT:
139 ret = QStringLiteral("Task failed to start");139 ret = QStringLiteral("Task failed to start");
140 break;140 break;
141 case keeper::KeeperError::HELPER_READ_ERROR:141 case keeper::Error::HELPER_READ:
142 ret = QStringLiteral("Read error");142 ret = QStringLiteral("Read error");
143 break;143 break;
144 case keeper::KeeperError::HELPER_SOCKET_ERROR:144 case keeper::Error::HELPER_SOCKET:
145 ret = QStringLiteral("Error creating internal socket");145 ret = QStringLiteral("Error creating internal socket");
146 break;146 break;
147 case keeper::KeeperError::HELPER_WRITE_ERROR:147 case keeper::Error::HELPER_WRITE:
148 ret = QStringLiteral("Write error");148 ret = QStringLiteral("Write error");
149 break;149 break;
150 case keeper::KeeperError::MANIFEST_STORAGE_ERROR:150 case keeper::Error::MANIFEST_STORAGE:
151 ret = QStringLiteral("Error storing manifest file");151 ret = QStringLiteral("Error storing manifest file");
152 break;152 break;
153 case keeper::KeeperError::NO_HELPER_INFORMATION_IN_REGISTRY:153 case keeper::Error::NO_HELPER_INFORMATION_IN_REGISTRY:
154 ret = QStringLiteral("No helper information in registry");154 ret = QStringLiteral("No helper information in registry");
155 break;155 break;
156 case keeper::KeeperError::OK:156 case keeper::Error::OK:
157 ret = QStringLiteral("Success");157 ret = QStringLiteral("Success");
158 break;158 break;
159 case keeper::KeeperError::COMMITTING_DATA_ERROR:159 case keeper::Error::COMMITTING_DATA:
160 ret = QStringLiteral("Error uploading data");160 ret = QStringLiteral("Error uploading data");
161 break;161 break;
162 case keeper::Error::CREATING_REMOTE_DIR:
163 ret = QStringLiteral("Error creating remote directory");
164 break;
165 case keeper::Error::CREATING_REMOTE_FILE:
166 ret = QStringLiteral("Error creating remote file");
167 break;
168 case keeper::Error::READING_REMOTE_FILE:
169 ret = QStringLiteral("Error reading remote file");
170 break;
171 case keeper::Error::REMOTE_DIR_NOT_EXISTS:
172 ret = QStringLiteral("Remote directory does not exist");
173 break;
174 case keeper::Error::NO_REMOTE_ACCOUNTS:
175 ret = QStringLiteral("No remote accounts were found");
176 break;
177 case keeper::Error::NO_REMOTE_ROOTS:
178 ret = QStringLiteral("No remote root accounts were found");
179 break;
162 }180 }
163 return ret;181 return ret;
164}182}
165183
166void CommandLineClientView::on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::KeeperError error)184void CommandLineClientView::on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::Error error)
167{185{
168 auto iter = tasks_strings_.find(displayName);186 auto iter = tasks_strings_.find(displayName);
169 if (iter != tasks_strings_.end())187 if (iter != tasks_strings_.end())
170188
=== modified file 'src/cli/command-line-client-view.h'
--- src/cli/command-line-client-view.h 2016-12-14 11:00:21 +0000
+++ src/cli/command-line-client-view.h 2016-12-22 14:35:27 +0000
@@ -42,15 +42,15 @@
42 void clear_all();42 void clear_all();
43 void print_sections(QStringList const & sections);43 void print_sections(QStringList const & sections);
44 void print_error_message(QString const & error_message);44 void print_error_message(QString const & error_message);
45 QString get_error_string(keeper::Error error);
4546
46public Q_SLOTS:47public Q_SLOTS:
47 void show_info();48 void show_info();
48 void on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::KeeperError error);49 void on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::Error error);
4950
50private:51private:
51 char get_next_spin_char();52 char get_next_spin_char();
52 QString get_task_string(QString const & displayName, QString const & status, double percentage, keeper::KeeperError error);53 QString get_task_string(QString const & displayName, QString const & status, double percentage, keeper::Error error);
53 QString get_error_string(keeper::KeeperError error);
5454
55 QString status_;55 QString status_;
56 QTimer timer_status_;56 QTimer timer_status_;
5757
=== modified file 'src/cli/command-line-client.cpp'
--- src/cli/command-line-client.cpp 2016-12-16 09:34:05 +0000
+++ src/cli/command-line-client.cpp 2016-12-22 14:35:27 +0000
@@ -42,15 +42,18 @@
4242
43void CommandLineClient::run_list_sections(bool remote)43void CommandLineClient::run_list_sections(bool remote)
44{44{
45 QMap<QString, QVariantMap> choices_values;45 keeper::KeeperItemsMap choices_values;
46 keeper::Error error;
46 if(!remote)47 if(!remote)
47 {48 {
48 choices_values = keeper_client_->getBackupChoices();49 choices_values = keeper_client_->getBackupChoices(error);
50 check_for_choices_error(error);
49 list_backup_sections(choices_values);51 list_backup_sections(choices_values);
50 }52 }
51 else53 else
52 {54 {
53 choices_values = keeper_client_->getRestoreChoices();55 choices_values = keeper_client_->getRestoreChoices(error);
56 check_for_choices_error(error);
54 list_restore_sections(choices_values);57 list_restore_sections(choices_values);
55 }58 }
56}59}
@@ -58,28 +61,27 @@
58void CommandLineClient::run_backup(QStringList & sections)61void CommandLineClient::run_backup(QStringList & sections)
59{62{
60 auto unhandled_sections = sections;63 auto unhandled_sections = sections;
61 auto choices_values = keeper_client_->getBackupChoices();64 keeper::Error error;
65 auto choices_values = keeper_client_->getBackupChoices(error);
66 check_for_choices_error(error);
62 QStringList uuids;67 QStringList uuids;
63 for(auto iter = choices_values.begin(); iter != choices_values.end() && unhandled_sections.size(); ++iter)68
69 auto uuids_choices = choices_values.get_uuids();
70 for(auto iter = uuids_choices.begin(); iter != uuids_choices.end() && unhandled_sections.size(); ++iter)
64 {71 {
65 const auto& values = iter.value();72 const auto& values = choices_values[(*iter)];
66 auto iter_values = values.find("type");73
67 if (iter_values != values.end())74 if (values.is_valid() && values.get_type() == "folder")
68 {75 {
69 if (iter_values.value() == "folder")76
77 auto display_name = values.get_display_name();
78 auto index = unhandled_sections.indexOf(display_name);
79 if (index != -1)
70 {80 {
71 auto iter_display_name = values.find("display-name");81 // we have to backup this section
72 if (iter_display_name != values.end())82 uuids << (*iter);
73 {83 unhandled_sections.removeAt(index);
74 auto index = unhandled_sections.indexOf((*iter_display_name).toString());84 view_->add_task(display_name, "waiting", 0.0);
75 if (index != -1)
76 {
77 // we have to backup this section
78 uuids << iter.key();
79 unhandled_sections.removeAt(index);
80 view_->add_task((*iter_display_name).toString(), "waiting", 0.0);
81 }
82 }
83 }85 }
84 }86 }
85 }87 }
@@ -106,34 +108,29 @@
106void CommandLineClient::run_restore(QStringList & sections)108void CommandLineClient::run_restore(QStringList & sections)
107{109{
108 auto unhandled_sections = sections;110 auto unhandled_sections = sections;
109 auto choices_values = keeper_client_->getRestoreChoices();111 keeper::Error error;
112 auto choices_values = keeper_client_->getRestoreChoices(error);
113 check_for_choices_error(error);
110 QStringList uuids;114 QStringList uuids;
111 for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)115
116 auto uuids_choices = choices_values.get_uuids();
117 for(auto iter = uuids_choices.begin(); iter != uuids_choices.end(); ++iter)
112 {118 {
113 const auto& values = iter.value();119 const auto& values = choices_values[(*iter)];
114120
115 QVariant choice_value;121 if (values.is_valid() && values.get_type() == "folder")
116 auto has_type = find_choice_value(values, "type", choice_value);
117 if (has_type && choice_value == "folder")
118 {122 {
119 QVariant display_name;123 auto display_name = values.get_display_name();
120 auto has_display_name = find_choice_value(values, "display-name", display_name);124 auto dir_name = values.get_dir_name();
121 if (!has_display_name)125
122 continue;126 auto section_name = QStringLiteral("%1:%2").arg(display_name).arg(dir_name);
123
124 QVariant dir_name;
125 auto has_dir_name = find_choice_value(values, "dir-name", dir_name);
126 if (!has_dir_name)
127 continue;
128
129 auto section_name = QStringLiteral("%1:%2").arg(display_name.toString()).arg(dir_name.toString());
130 auto index = unhandled_sections.indexOf(section_name);127 auto index = unhandled_sections.indexOf(section_name);
131 if (index != -1)128 if (index != -1)
132 {129 {
133 // we have to restore this section130 // we have to restore this section
134 uuids << iter.key();131 uuids << (*iter);
135 unhandled_sections.removeAt(index);132 unhandled_sections.removeAt(index);
136 view_->add_task(display_name.toString(), "waiting", 0.0);133 view_->add_task(display_name, "waiting", 0.0);
137 }134 }
138 }135 }
139 }136 }
@@ -156,45 +153,34 @@
156 view_->start_printing_tasks();153 view_->start_printing_tasks();
157}154}
158155
159void CommandLineClient::list_backup_sections(QMap<QString, QVariantMap> const & choices_values)156void CommandLineClient::list_backup_sections(keeper::KeeperItemsMap const & choices_values)
160{157{
161 QStringList sections;158 QStringList sections;
162 for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)159 for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
163 {160 {
164 const auto& values = iter.value();161 if ((*iter).is_valid() && (*iter).get_type() == "folder")
165162 {
166 QVariant choice_value;163 sections << (*iter).get_display_name();
167 auto has_type = find_choice_value(values, "type", choice_value);164 }
168 if (has_type && choice_value == "folder")165 }
169 {166 view_->print_sections(sections);
170 auto has_display_name = find_choice_value(values, "display-name", choice_value);167}
171 if (has_display_name)168
169void CommandLineClient::list_restore_sections(keeper::KeeperItemsMap const & choices_values)
170{
171 QMap<QString, QList<keeper::KeeperItem>> values_per_dir;
172
173 for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
174 {
175 if ((*iter).is_valid() && (*iter).get_type() == "folder")
176 {
177 auto dir_name = (*iter).get_dir_name();
178 if (!dir_name.isEmpty())
172 {179 {
173 sections << choice_value.toString();180 values_per_dir[dir_name].push_back((*iter));
174 }181 }
175 }182 }
176 }183 }
177 view_->print_sections(sections);
178}
179
180void CommandLineClient::list_restore_sections(QMap<QString, QVariantMap> const & choices_values)
181{
182 QMap<QString, QList<QVariantMap>> values_per_dir;
183
184 for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
185 {
186 const auto& values = iter.value();
187
188 QVariant choice_value;
189 auto has_type = find_choice_value(values, "type", choice_value);
190 if (has_type && choice_value == "folder")
191 {
192 auto has_dir_name = find_choice_value(values, "dir-name", choice_value);
193 if (!has_dir_name)
194 continue;
195 values_per_dir[choice_value.toString()].push_back(values);
196 }
197 }
198184
199 QStringList sections;185 QStringList sections;
200 for(auto iter = values_per_dir.begin(); iter != values_per_dir.end(); ++iter)186 for(auto iter = values_per_dir.begin(); iter != values_per_dir.end(); ++iter)
@@ -202,17 +188,7 @@
202 for(auto iter_items = (*iter).begin(); iter_items != (*iter).end(); ++iter_items)188 for(auto iter_items = (*iter).begin(); iter_items != (*iter).end(); ++iter_items)
203 {189 {
204 const auto& values = (*iter_items);190 const auto& values = (*iter_items);
205191 sections << QStringLiteral("%1:%2").arg(values.get_display_name()).arg(iter.key());
206 QVariant choice_value;
207 auto has_type = find_choice_value(values, "type", choice_value);
208 if (has_type && choice_value == "folder")
209 {
210 auto has_display_name = find_choice_value(values, "display-name", choice_value);
211 if (has_display_name)
212 {
213 sections << QStringLiteral("%1:%2").arg(choice_value.toString()).arg(iter.key());
214 }
215 }
216 }192 }
217 sections << "";193 sections << "";
218 }194 }
@@ -245,3 +221,14 @@
245 value = (*iter);221 value = (*iter);
246 return true;222 return true;
247}223}
224
225void CommandLineClient::check_for_choices_error(keeper::Error error)
226{
227 if (error != keeper::Error::OK)
228 {
229 // an error occurred
230 auto error_message = QStringLiteral("Error obtaining keeper choices: %1").arg(view_->get_error_string(error));
231 view_->print_error_message(error_message);
232 return;
233 }
234}
248235
=== modified file 'src/cli/command-line-client.h'
--- src/cli/command-line-client.h 2016-12-16 09:34:05 +0000
+++ src/cli/command-line-client.h 2016-12-22 14:35:27 +0000
@@ -22,6 +22,7 @@
22#include <QObject>22#include <QObject>
23#include <QScopedPointer>23#include <QScopedPointer>
24#include <QTimer>24#include <QTimer>
25#include "../../include/client/keeper-items.h"
2526
26class KeeperClient;27class KeeperClient;
27class CommandLineClientView;28class CommandLineClientView;
@@ -45,9 +46,10 @@
45 void on_keeper_client_finished();46 void on_keeper_client_finished();
4647
47private:48private:
48 static bool find_choice_value(QVariantMap const & choice, QString const & id, QVariant & value);49 bool find_choice_value(QVariantMap const & choice, QString const & id, QVariant & value);
49 void list_backup_sections(QMap<QString, QVariantMap> const & choices);50 void list_backup_sections(keeper::KeeperItemsMap const & choices);
50 void list_restore_sections(QMap<QString, QVariantMap> const & choices);51 void list_restore_sections(keeper::KeeperItemsMap const & choices);
52 void check_for_choices_error(keeper::Error error);
51 QScopedPointer<KeeperClient> keeper_client_;53 QScopedPointer<KeeperClient> keeper_client_;
52 QScopedPointer<CommandLineClientView> view_;54 QScopedPointer<CommandLineClientView> view_;
53};55};
5456
=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt 2016-12-14 12:03:22 +0000
+++ src/client/CMakeLists.txt 2016-12-22 14:35:27 +0000
@@ -10,12 +10,15 @@
10 STATIC10 STATIC
11 keeper-errors.cpp11 keeper-errors.cpp
12 ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h12 ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h
13 ${CMAKE_SOURCE_DIR}/include/client/keeper-items.h
14 keeper-items.cpp
13)15)
1416
15set(17set(
16 CLIENT_HEADERS18 CLIENT_HEADERS
17 ${CMAKE_SOURCE_DIR}/include/client/client.h19 ${CMAKE_SOURCE_DIR}/include/client/client.h
18 ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h20 ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h
21 ${CMAKE_SOURCE_DIR}/include/client/keeper-items.h
19)22)
2023
21add_library(24add_library(
2225
=== modified file 'src/client/client.cpp'
--- src/client/client.cpp 2016-12-21 17:19:46 +0000
+++ src/client/client.cpp 2016-12-22 14:35:27 +0000
@@ -23,6 +23,7 @@
2323
24#include <qdbus-stubs/keeper_user_interface.h>24#include <qdbus-stubs/keeper_user_interface.h>
25#include <qdbus-stubs/DBusPropertiesInterface.h>25#include <qdbus-stubs/DBusPropertiesInterface.h>
26#include <qdbus-stubs/dbus-types.h>
2627
27struct KeeperClientPrivate final28struct KeeperClientPrivate final
28{29{
@@ -57,7 +58,7 @@
57 return (stateString == "complete" || stateString == "cancelled" || stateString == "failed");58 return (stateString == "complete" || stateString == "cancelled" || stateString == "failed");
58 }59 }
5960
60 static bool checkAllTasksFinished(QMap<QString, QVariantMap> const & state)61 bool checkAllTasksFinished(keeper::KeeperItemsMap const & state) const
61 {62 {
62 bool ret = true;63 bool ret = true;
63 for (auto iter = state.begin(); ret && (iter != state.end()); ++iter)64 for (auto iter = state.begin(); ret && (iter != state.end()); ++iter)
@@ -68,15 +69,52 @@
68 return ret;69 return ret;
69 }70 }
7071
72 static keeper::KeeperItemsMap getValue(QDBusMessage const & message, keeper::Error & error)
73 {
74 if (message.errorMessage().isEmpty())
75 {
76 if (message.arguments().count() != 1)
77 {
78 error = keeper::Error::UNKNOWN;
79 return keeper::KeeperItemsMap();
80 }
81
82 auto value = message.arguments().at(0);
83 if (value.typeName() != QStringLiteral("QDBusArgument"))
84 {
85 error = keeper::Error::UNKNOWN;
86 return keeper::KeeperItemsMap();
87 }
88 auto dbus_arg = value.value<QDBusArgument>();
89 error = keeper::Error::OK;
90 keeper::KeeperItemsMap ret;
91 dbus_arg >> ret;
92 return ret;
93 }
94 if (message.arguments().count() != 2)
95 {
96 error = keeper::Error::UNKNOWN;
97 return keeper::KeeperItemsMap();
98 }
99
100 // pick up the error
101 bool valid;
102 error = keeper::convert_from_dbus_variant(message.arguments().at(1), &valid);
103 if (!valid)
104 {
105 error = keeper::Error::UNKNOWN;
106 }
107 return keeper::KeeperItemsMap();
108 }
109
71 QScopedPointer<DBusInterfaceKeeperUser> userIface;110 QScopedPointer<DBusInterfaceKeeperUser> userIface;
72 QScopedPointer<DBusPropertiesInterface> propertiesIface;111 QScopedPointer<DBusPropertiesInterface> propertiesIface;
73 QString status;112 QString status;
74 QMap<QString, QVariantMap> backups;113 keeper::KeeperItemsMap backups;
75 QMap<QString, QVariantMap> restores;
76 double progress = 0;114 double progress = 0;
77 bool readyToBackup = false;115 bool readyToBackup = false;
78 bool backupBusy = false;116 bool backupBusy = false;
79 QMap<QString, TaskStatus> task_status;117 QMap<QString, TaskStatus> taskStatus;
80 TasksMode mode = TasksMode::IDLE_MODE;118 TasksMode mode = TasksMode::IDLE_MODE;
81};119};
82120
@@ -88,7 +126,9 @@
88126
89 // Store backups list locally with an additional "enabled" pair to keep track enabled states127 // Store backups list locally with an additional "enabled" pair to keep track enabled states
90 // TODO: We should be listening to a backupChoicesChanged signal to keep this list updated128 // TODO: We should be listening to a backupChoicesChanged signal to keep this list updated
91 d->backups = getBackupChoices();129 keeper::Error error;
130 d->backups = getBackupChoices(error);
131
92 for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)132 for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
93 {133 {
94 iter.value()["enabled"] = false;134 iter.value()["enabled"] = false;
@@ -148,7 +188,7 @@
148 }188 }
149 }189 }
150190
151 d->task_status[uuid] = KeeperClientPrivate::TaskStatus{"", 0.0};191 d->taskStatus[uuid] = KeeperClientPrivate::TaskStatus{"", 0.0};
152192
153 Q_EMIT readyToBackupChanged();193 Q_EMIT readyToBackupChanged();
154}194}
@@ -212,31 +252,16 @@
212 return d->backups.value(uuid).value("display-name").toString();252 return d->backups.value(uuid).value("display-name").toString();
213}253}
214254
215QMap<QString, QVariantMap> KeeperClient::getBackupChoices() const255keeper::KeeperItemsMap KeeperClient::getBackupChoices(keeper::Error & error) const
216{256{
217 QDBusReply<QMap<QString, QVariantMap>> choices = d->userIface->call("GetBackupChoices");257 QDBusMessage choices = d->userIface->call("GetBackupChoices");
218258 return KeeperClientPrivate::getValue(choices, error);
219 if (!choices.isValid())
220 {
221 qWarning() << "Error getting backup choices:" << choices.error().message();
222 return QMap<QString, QVariantMap>();
223 }
224
225 return choices.value();
226}259}
227260
228QMap<QString, QVariantMap> KeeperClient::getRestoreChoices() const261keeper::KeeperItemsMap KeeperClient::getRestoreChoices(keeper::Error & error) const
229{262{
230 QDBusPendingReply<QMap<QString, QVariantMap>> choices = d->userIface->call("GetRestoreChoices");263 QDBusMessage choices = d->userIface->call("GetRestoreChoices");
231264 return KeeperClientPrivate::getValue(choices, error);
232 choices.waitForFinished();
233 if (!choices.isValid())
234 {
235 qWarning() << "Error getting restore choices:" << choices.error().message();
236 return QMap<QString, QVariantMap>();
237 }
238
239 return choices.value();
240}265}
241266
242void KeeperClient::startBackup(const QStringList& uuids) const267void KeeperClient::startBackup(const QStringList& uuids) const
@@ -259,7 +284,7 @@
259 }284 }
260}285}
261286
262QMap<QString, QVariantMap> KeeperClient::getState() const287keeper::KeeperItemsMap KeeperClient::getState() const
263{288{
264 return d->userIface->state();289 return d->userIface->state();
265}290}
@@ -270,38 +295,32 @@
270295
271 if (!states.empty())296 if (!states.empty())
272 {297 {
273 for (auto const & uuid : d->task_status.keys())298 for (auto const & uuid : d->taskStatus.keys())
274 {299 {
275 auto iter_state = states.find(uuid);300 auto iter_state = states.find(uuid);
276 if (iter_state == states.end())301 if (iter_state == states.end())
277 {302 {
278 qWarning() << "State for uuid: " << uuid << " was not found";303 qWarning() << "State for uuid: " << uuid << " was not found";
279 }304 }
280 auto state = (*iter_state);305 keeper::KeeperItem keeper_item((*iter_state));
281 double progress = state.value("percent-done").toDouble();306 auto progress = keeper_item.get_percent_done();
282 auto status = state.value("action").toString();307 auto status = keeper_item.get_status();
283308 auto keeper_error = keeper_item.get_error();
284 keeper::KeeperError keeper_error = keeper::KeeperError::OK;309
285 auto iter_error = state.find("error");310 auto current_state = d->taskStatus[uuid];
286 if (iter_error != state.end())
287 {
288 bool conversion_ok;
289 keeper_error = keeper::convertFromDBusVariant(state.value("error"), &conversion_ok);
290 }
291
292 auto current_state = d->task_status[uuid];
293 if (current_state.status != status || current_state.percentage < progress)311 if (current_state.status != status || current_state.percentage < progress)
294 {312 {
295 d->task_status[uuid].status = status;313 d->taskStatus[uuid].status = status;
296 d->task_status[uuid].percentage = progress;314 d->taskStatus[uuid].percentage = progress;
297 Q_EMIT(taskStatusChanged(state.value("display-name").toString(), status, progress, keeper_error));315 Q_EMIT(taskStatusChanged(keeper_item.get_display_name(), status, progress, keeper_error));
298 }316 }
299 }317 }
300318
301 double totalProgress = 0;319 double totalProgress = 0;
302 for (auto const& state : states)320 for (auto const& state : states)
303 {321 {
304 totalProgress += state.value("percent-done").toDouble();322 keeper::KeeperItem keeper_item(state);
323 totalProgress += keeper_item.get_percent_done();
305 }324 }
306325
307 d->progress = totalProgress / states.count();326 d->progress = totalProgress / states.count();
308327
=== modified file 'src/client/keeper-errors.cpp'
--- src/client/keeper-errors.cpp 2016-12-21 08:36:57 +0000
+++ src/client/keeper-errors.cpp 2016-12-22 14:35:27 +0000
@@ -21,7 +21,7 @@
2121
22#include <QDebug>22#include <QDebug>
2323
24QDBusArgument &operator<<(QDBusArgument &argument, keeper::KeeperError value)24QDBusArgument &operator<<(QDBusArgument &argument, keeper::Error value)
25{25{
26 argument.beginStructure();26 argument.beginStructure();
27 argument << static_cast<int>(value);27 argument << static_cast<int>(value);
@@ -29,41 +29,41 @@
29 return argument;29 return argument;
30}30}
3131
32const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::KeeperError &val)32const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::Error &val)
33{33{
34 int int_val;34 int int_val;
35 argument.beginStructure();35 argument.beginStructure();
36 argument >> int_val;36 argument >> int_val;
37 val = static_cast<keeper::KeeperError>(int_val);37 val = static_cast<keeper::Error>(int_val);
38 argument.endStructure();38 argument.endStructure();
39 return argument;39 return argument;
40}40}
4141
42namespace keeper42namespace keeper
43{43{
44KeeperError convertFromDBusVariant(const QVariant & value, bool *conversion_ok)44Error convert_from_dbus_variant(const QVariant & value, bool *conversion_ok)
45{45{
46 if (value.typeName() != QStringLiteral("QDBusArgument"))46 if (value.typeName() != QStringLiteral("QDBusArgument"))
47 {47 {
48 qWarning() << Q_FUNC_INFO48 qWarning() << Q_FUNC_INFO
49 << " Error converting dbus QVariant to KeeperError, expected type is [ QDBusArgument ] and current type is: ["49 << " Error converting dbus QVariant to Error, expected type is [ QDBusArgument ] and current type is: ["
50 << value.typeName() << "]";50 << value.typeName() << "]";
51 if (conversion_ok)51 if (conversion_ok)
52 *conversion_ok = false;52 *conversion_ok = false;
53 return KeeperError(keeper::KeeperError::ERROR_UNKNOWN);53 return Error(keeper::Error::UNKNOWN);
54 }54 }
55 auto dbus_arg = value.value<QDBusArgument>();55 auto dbus_arg = value.value<QDBusArgument>();
5656
57 if (dbus_arg.currentSignature() != "(i)")57 if (dbus_arg.currentSignature() != "(i)")
58 {58 {
59 qWarning() << Q_FUNC_INFO59 qWarning() << Q_FUNC_INFO
60 << " Error converting dbus QVariant to KeeperError, expected signature is \"(i)\" and current signature is: \""60 << " Error converting dbus QVariant to Error, expected signature is \"(i)\" and current signature is: \""
61 << dbus_arg.currentSignature() << "\"";61 << dbus_arg.currentSignature() << "\"";
62 if (conversion_ok)62 if (conversion_ok)
63 *conversion_ok = false;63 *conversion_ok = false;
64 return KeeperError(keeper::KeeperError::ERROR_UNKNOWN);64 return Error(keeper::Error::UNKNOWN);
65 }65 }
66 KeeperError ret;66 Error ret;
67 dbus_arg >> ret;67 dbus_arg >> ret;
6868
69 if (conversion_ok)69 if (conversion_ok)
7070
=== added file 'src/client/keeper-items.cpp'
--- src/client/keeper-items.cpp 1970-01-01 00:00:00 +0000
+++ src/client/keeper-items.cpp 2016-12-22 14:35:27 +0000
@@ -0,0 +1,212 @@
1/*
2 * Copyright (C) 2016 Canonical, Ltd.
3 *
4 * This program is free software: you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 3, as published
6 * by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranties of
10 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
11 * PURPOSE. See the GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Authors:
17 * Xavi Garcia Mena <xavi.garcia.mena@canonical.com>
18 */
19
20#include "client/keeper-items.h"
21
22#include <QtDBus>
23#include <QVariantMap>
24
25namespace keeper
26{
27
28// KeeperItem
29
30bool has_all_predefined_properties(QStringList const & predefined_properties, KeeperItem const & values);
31
32bool has_all_predefined_properties(QStringList const & predefined_properties, KeeperItem const & values)
33{
34 for (auto iter = predefined_properties.begin(); iter != predefined_properties.end(); ++iter)
35 {
36 if (!values.has_property((*iter)))
37 return false;
38 }
39 return true;
40}
41
42constexpr const char TYPE_KEY[] = "type";
43constexpr const char DISPLAY_NAME_KEY[] = "display-name";
44constexpr const char DIR_NAME_KEY[] = "dir-name";
45constexpr const char STATUS_KEY[] = "action";
46constexpr const char PERCENT_DONE_KEY[] = "percent-done";
47constexpr const char ERROR_KEY[] = "error";
48
49
50KeeperItem::KeeperItem()
51 : QVariantMap()
52{
53}
54
55KeeperItem::KeeperItem(QVariantMap const & values)
56 : QVariantMap(values)
57{
58}
59
60KeeperItem::~KeeperItem() = default;
61
62QVariant KeeperItem::get_property_value(QString const & property) const
63{
64 auto iter = this->find(property);
65 if (iter != this->end())
66 {
67 return (*iter);
68 }
69 else
70 {
71 return QVariant();
72 }
73}
74
75bool KeeperItem::is_valid()const
76{
77 // we need at least type and display name to consider this a keeper item
78 return has_all_predefined_properties(QStringList{TYPE_KEY, DISPLAY_NAME_KEY}, *this);
79}
80
81bool KeeperItem::has_property(QString const & property) const
82{
83 auto iter = this->find(property);
84 return iter != this->end();
85}
86
87QString KeeperItem::get_type(bool *valid) const
88{
89 if (!has_property(TYPE_KEY))
90 {
91 if (valid)
92 *valid = false;
93 return QString();
94 }
95 if (valid)
96 *valid = true;
97 return get_property_value(TYPE_KEY).toString();
98}
99
100QString KeeperItem::get_display_name(bool *valid) const
101{
102 if (!has_property(DISPLAY_NAME_KEY))
103 {
104 if (valid)
105 *valid = false;
106 return QString();
107 }
108 if (valid)
109 *valid = true;
110 return get_property_value(DISPLAY_NAME_KEY).toString();
111}
112
113QString KeeperItem::get_dir_name(bool *valid) const
114{
115 if (!has_property(DIR_NAME_KEY))
116 {
117 if (valid)
118 *valid = false;
119 return QString();
120 }
121 if (valid)
122 *valid = true;
123 return get_property_value(DIR_NAME_KEY).toString();
124}
125
126QString KeeperItem::get_status(bool *valid) const
127{
128 if (!has_property(STATUS_KEY))
129 {
130 if (valid)
131 *valid = false;
132 return QString();
133 }
134 if (valid)
135 *valid = true;
136 return get_property_value(STATUS_KEY).toString();
137}
138
139double KeeperItem::get_percent_done(bool *valid) const
140{
141 auto value = get_property_value(PERCENT_DONE_KEY);
142 if (value.type() == QVariant::Double)
143 {
144 if (valid)
145 *valid = true;
146 return get_property_value(PERCENT_DONE_KEY).toDouble();
147 }
148 else
149 {
150 if (valid)
151 *valid = false;
152 return -1;
153 }
154}
155
156keeper::Error KeeperItem::get_error(bool *valid) const
157{
158 // if it does not have explicitly defined the error, OK is considered
159 if (!has_property(ERROR_KEY))
160 return keeper::Error::OK;
161
162 return keeper::convert_from_dbus_variant(get_property_value(ERROR_KEY), valid);
163}
164
165void KeeperItem::registerMetaType()
166{
167 qRegisterMetaType<KeeperItem>("KeeperItem");
168
169 qDBusRegisterMetaType<KeeperItem>();
170}
171
172/////
173// KeeperItemsMap
174/////
175
176
177KeeperItemsMap::KeeperItemsMap()
178 : QMap<QString, KeeperItem>()
179{
180}
181
182KeeperItemsMap::~KeeperItemsMap() = default;
183
184
185KeeperItemsMap::KeeperItemsMap(Error error)
186 : QMap<QString, KeeperItem>()
187 , error_(error)
188{
189
190}
191
192QStringList KeeperItemsMap::get_uuids() const
193{
194 QStringList ret;
195 for (auto iter = this->begin(); iter != this->end(); ++iter)
196 {
197 ret << iter.key();
198 }
199
200 return ret;
201}
202
203void KeeperItemsMap::registerMetaType()
204{
205 qRegisterMetaType<KeeperItemsMap>("KeeperItemsMap");
206
207 qDBusRegisterMetaType<KeeperItemsMap>();
208
209 KeeperItem::registerMetaType();
210}
211
212} // namespace keeper
0213
=== modified file 'src/helper/backup-helper.cpp'
--- src/helper/backup-helper.cpp 2016-12-15 14:30:42 +0000
+++ src/helper/backup-helper.cpp 2016-12-22 14:35:27 +0000
@@ -63,7 +63,7 @@
63 if (rc == -1)63 if (rc == -1)
64 {64 {
65 qWarning() << QStringLiteral("Error creating socket to communicate with helper");;65 qWarning() << QStringLiteral("Error creating socket to communicate with helper");;
66 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_SOCKET_ERROR));66 Q_EMIT(q_ptr->error(keeper::Error::HELPER_SOCKET));
67 return;67 return;
68 }68 }
6969
@@ -142,7 +142,7 @@
142 if (!success)142 if (!success)
143 {143 {
144 write_error_ = true;144 write_error_ = true;
145 Q_EMIT(q_ptr->error(keeper::KeeperError::COMMITTING_DATA_ERROR));145 Q_EMIT(q_ptr->error(keeper::Error::COMMITTING_DATA));
146 }146 }
147 else147 else
148 uploader_committed_file_name_ = uploader_->file_name();148 uploader_committed_file_name_ = uploader_->file_name();
@@ -178,7 +178,7 @@
178 {178 {
179 stop_inactivity_timer();179 stop_inactivity_timer();
180 qWarning() << "Inactivity detected in the helper...stopping it";180 qWarning() << "Inactivity detected in the helper...stopping it";
181 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_INACTIVITY_DETECTED));181 Q_EMIT(q_ptr->error(keeper::Error::HELPER_INACTIVITY_DETECTED));
182 stop();182 stop();
183 }183 }
184184
@@ -214,7 +214,7 @@
214 }214 }
215 else if (n < 0) {215 else if (n < 0) {
216 read_error_ = true;216 read_error_ = true;
217 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_READ_ERROR));217 Q_EMIT(q_ptr->error(keeper::Error::HELPER_READ));
218 stop();218 stop();
219 return;219 return;
220 }220 }
@@ -230,7 +230,7 @@
230 if (n < 0) {230 if (n < 0) {
231 write_error_ = true;231 write_error_ = true;
232 qWarning() << "Write error:" << socket->errorString();232 qWarning() << "Write error:" << socket->errorString();
233 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_WRITE_ERROR));233 Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
234 stop();234 stop();
235 }235 }
236 break;236 break;
@@ -263,7 +263,7 @@
263 {263 {
264 if (n_uploaded_ > q_ptr->expected_size())264 if (n_uploaded_ > q_ptr->expected_size())
265 {265 {
266 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_WRITE_ERROR));266 Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
267 }267 }
268 q_ptr->set_state(Helper::State::FAILED);268 q_ptr->set_state(Helper::State::FAILED);
269 }269 }
270270
=== modified file 'src/helper/helper.cpp'
--- src/helper/helper.cpp 2016-12-21 17:29:58 +0000
+++ src/helper/helper.cpp 2016-12-22 14:35:27 +0000
@@ -354,7 +354,7 @@
354 void on_max_time_waiting_for_ual_started()354 void on_max_time_waiting_for_ual_started()
355 {355 {
356 qWarning() << "Maximum time reached waiting for the helper to start.";356 qWarning() << "Maximum time reached waiting for the helper to start.";
357 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_START_TIMEOUT));357 Q_EMIT(q_ptr->error(keeper::Error::HELPER_START_TIMEOUT));
358 q_ptr->set_state(Helper::State::FAILED);358 q_ptr->set_state(Helper::State::FAILED);
359 stop_wait_for_ual_timer();359 stop_wait_for_ual_timer();
360 }360 }
361361
=== modified file 'src/helper/restore-helper.cpp'
--- src/helper/restore-helper.cpp 2016-12-15 14:30:42 +0000
+++ src/helper/restore-helper.cpp 2016-12-22 14:35:27 +0000
@@ -58,7 +58,7 @@
58 if (rc == -1)58 if (rc == -1)
59 {59 {
60 qWarning() << QStringLiteral("Error creating socket to communicate with helper");;60 qWarning() << QStringLiteral("Error creating socket to communicate with helper");;
61 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_SOCKET_ERROR));61 Q_EMIT(q_ptr->error(keeper::Error::HELPER_SOCKET));
62 return;62 return;
63 }63 }
6464
@@ -167,7 +167,7 @@
167 {167 {
168 stop_inactivity_timer();168 stop_inactivity_timer();
169 qWarning() << "Inactivity detected in the helper...stopping it";169 qWarning() << "Inactivity detected in the helper...stopping it";
170 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_INACTIVITY_DETECTED));170 Q_EMIT(q_ptr->error(keeper::Error::HELPER_INACTIVITY_DETECTED));
171 stop();171 stop();
172 }172 }
173173
@@ -206,7 +206,7 @@
206 else if (n < 0) {206 else if (n < 0) {
207 read_error_ = true;207 read_error_ = true;
208 qDebug() << "Read error in restore helper: " << socket->errorString();208 qDebug() << "Read error in restore helper: " << socket->errorString();
209 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_READ_ERROR));209 Q_EMIT(q_ptr->error(keeper::Error::HELPER_READ));
210 stop();210 stop();
211 return;211 return;
212 }212 }
@@ -225,7 +225,7 @@
225 if (n < 0) {225 if (n < 0) {
226 write_error_ = true;226 write_error_ = true;
227 qWarning() << "Write error:" << write_socket_.errorString();227 qWarning() << "Write error:" << write_socket_.errorString();
228 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_WRITE_ERROR));228 Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
229 stop();229 stop();
230 }230 }
231 break;231 break;
@@ -259,7 +259,7 @@
259 {259 {
260 if (n_uploaded_ > q_ptr->expected_size())260 if (n_uploaded_ > q_ptr->expected_size())
261 {261 {
262 Q_EMIT(q_ptr->error(keeper::KeeperError::HELPER_WRITE_ERROR));262 Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
263 }263 }
264 q_ptr->set_state(Helper::State::FAILED);264 q_ptr->set_state(Helper::State::FAILED);
265 }265 }
266266
=== modified file 'src/qdbus-stubs/CMakeLists.txt'
--- src/qdbus-stubs/CMakeLists.txt 2016-11-30 14:46:29 +0000
+++ src/qdbus-stubs/CMakeLists.txt 2016-12-22 14:35:27 +0000
@@ -67,6 +67,7 @@
67 ${user_xml}67 ${user_xml}
68 PROPERTIES68 PROPERTIES
69 CLASSNAME DBusInterfaceKeeperUser69 CLASSNAME DBusInterfaceKeeperUser
70 INCLUDE "client/keeper-items.h"
70)71)
7172
72qt5_add_dbus_interface(73qt5_add_dbus_interface(
@@ -116,7 +117,7 @@
116 ${adaptor_files}117 ${adaptor_files}
117)118)
118119
119#target_link_libraries(120target_link_libraries(
120# ${STUBS_LIB}121 ${STUBS_LIB}
121# backup-helper122 keeper-errors-lib
122#)123)
123124
=== modified file 'src/qdbus-stubs/com.canonical.keeper.User.xml'
--- src/qdbus-stubs/com.canonical.keeper.User.xml 2016-07-28 19:44:52 +0000
+++ src/qdbus-stubs/com.canonical.keeper.User.xml 2016-12-22 14:35:27 +0000
@@ -5,7 +5,7 @@
5 <interface name="com.canonical.keeper.User">5 <interface name="com.canonical.keeper.User">
66
7 <method name="GetBackupChoices">7 <method name="GetBackupChoices">
8 <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantDictMap"/>8 <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="keeper::KeeperItemsMap"/>
9 <arg direction="out" name="backups" type="a{sa{sv}}">9 <arg direction="out" name="backups" type="a{sa{sv}}">
10 <doc:doc>10 <doc:doc>
11 <doc:summary>A list of backup possibilities for the user to choose from</doc:summary>11 <doc:summary>A list of backup possibilities for the user to choose from</doc:summary>
@@ -35,7 +35,7 @@
35 </method>35 </method>
3636
37 <method name="GetRestoreChoices">37 <method name="GetRestoreChoices">
38 <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantDictMap"/>38 <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="keeper::KeeperItemsMap"/>
39 <arg direction="out" name="backups" type="a{sa{sv}}">39 <arg direction="out" name="backups" type="a{sa{sv}}">
40 <doc:doc>40 <doc:doc>
41 <doc:summary>The backups which already exist and can be restored</doc:summary>41 <doc:summary>The backups which already exist and can be restored</doc:summary>
@@ -65,7 +65,7 @@
65 </method>65 </method>
6666
67 <property name="State" type="a{sa{sv}}" access="read">67 <property name="State" type="a{sa{sv}}" access="read">
68 <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantDictMap"/>68 <annotation name="org.qtproject.QtDBus.QtTypeName" value="keeper::KeeperItemsMap"/>
69 <doc:doc>69 <doc:doc>
70 <doc:description>70 <doc:description>
71 <doc:para>Provides state information so the user interface can show71 <doc:para>Provides state information so the user interface can show
7272
=== modified file 'src/qdbus-stubs/dbus-types.h'
--- src/qdbus-stubs/dbus-types.h 2016-12-14 11:00:21 +0000
+++ src/qdbus-stubs/dbus-types.h 2016-12-22 14:35:27 +0000
@@ -23,6 +23,7 @@
23#include <QString>23#include <QString>
24#include <QVariantMap>24#include <QVariantMap>
25#include <client/keeper-errors.h>25#include <client/keeper-errors.h>
26#include "client/keeper-items.h"
2627
27typedef QMap<QString, QVariantMap> QVariantDictMap;28typedef QMap<QString, QVariantMap> QVariantDictMap;
28Q_DECLARE_METATYPE(QVariantDictMap)29Q_DECLARE_METATYPE(QVariantDictMap)
@@ -36,11 +37,13 @@
36 {37 {
37 qRegisterMetaType<QVariantDictMap>("QVariantDictMap");38 qRegisterMetaType<QVariantDictMap>("QVariantDictMap");
38 qRegisterMetaType<QStringMap>("QStringMap");39 qRegisterMetaType<QStringMap>("QStringMap");
39 qRegisterMetaType<keeper::KeeperError>("keeper::KeeperError");40 qRegisterMetaType<keeper::Error>("keeper::Error");
4041
41 qDBusRegisterMetaType<QVariantDictMap>();42 qDBusRegisterMetaType<QVariantDictMap>();
42 qDBusRegisterMetaType<QStringMap>();43 qDBusRegisterMetaType<QStringMap>();
43 qDBusRegisterMetaType<keeper::KeeperError>();44 qDBusRegisterMetaType<keeper::Error>();
45
46 keeper::KeeperItemsMap::registerMetaType();
44 }47 }
4548
46 constexpr const char KEEPER_SERVICE[] = "com.canonical.keeper";49 constexpr const char KEEPER_SERVICE[] = "com.canonical.keeper";
4750
=== modified file 'src/service/backup-choices.cpp'
--- src/service/backup-choices.cpp 2016-10-28 15:11:21 +0000
+++ src/service/backup-choices.cpp 2016-12-22 14:35:27 +0000
@@ -160,5 +160,5 @@
160 }160 }
161 }161 }
162162
163 Q_EMIT(finished());163 Q_EMIT(finished(keeper::Error::OK));
164}164}
165165
=== modified file 'src/service/keeper-task-backup.cpp'
--- src/service/keeper-task-backup.cpp 2016-12-15 14:30:42 +0000
+++ src/service/keeper-task-backup.cpp 2016-12-22 14:35:27 +0000
@@ -50,7 +50,7 @@
50 qDebug() << "Initializing a backup helper";50 qDebug() << "Initializing a backup helper";
51 helper_.reset(new BackupHelper(DEKKO_APP_ID), [](Helper *h){h->deleteLater();});51 helper_.reset(new BackupHelper(DEKKO_APP_ID), [](Helper *h){h->deleteLater();});
52 qDebug() << "Helper " << static_cast<void*>(helper_.data()) << " was created";52 qDebug() << "Helper " << static_cast<void*>(helper_.data()) << " was created";
53 QObject::connect(helper_.data(), &Helper::error, [this](keeper::KeeperError error){ error_ = error;});53 QObject::connect(helper_.data(), &Helper::error, [this](keeper::Error error){ error_ = error;});
54 }54 }
5555
56 void ask_for_uploader(quint64 n_bytes, QString const & dir_name)56 void ask_for_uploader(quint64 n_bytes, QString const & dir_name)
@@ -65,14 +65,20 @@
65 storage_->get_new_uploader(n_bytes, dir_name, file_name),65 storage_->get_new_uploader(n_bytes, dir_name, file_name),
66 std::function<void(std::shared_ptr<Uploader> const&)>{66 std::function<void(std::shared_ptr<Uploader> const&)>{
67 [this](std::shared_ptr<Uploader> const& uploader){67 [this](std::shared_ptr<Uploader> const& uploader){
68 int fd {-1};68 auto fd {-1};
69 if (uploader) {69 if (uploader) {
70 auto backup_helper = qSharedPointerDynamicCast<BackupHelper>(helper_);70 auto backup_helper = qSharedPointerDynamicCast<BackupHelper>(helper_);
71 backup_helper->set_uploader(uploader);71 backup_helper->set_uploader(uploader);
72 fd = backup_helper->get_helper_socket();72 fd = backup_helper->get_helper_socket();
73 }73 qDebug("emitting task_socket_ready(socket=%d)", fd);
74 qDebug("emitting task_socket_ready(socket=%d)", fd);74 Q_EMIT(q_ptr->task_socket_ready(fd));
75 Q_EMIT(q_ptr->task_socket_ready(fd));75 }
76 else
77 {
78 error_ = storage_->get_last_error();
79 qDebug("Emitting task_socket_error(error=%d)", static_cast<int>(error_));
80 Q_EMIT(q_ptr->task_socket_error(error_));
81 }
76 }82 }
77 }83 }
78 );84 );
7985
=== modified file 'src/service/keeper-task-restore.cpp'
--- src/service/keeper-task-restore.cpp 2016-12-15 14:30:42 +0000
+++ src/service/keeper-task-restore.cpp 2016-12-22 14:35:27 +0000
@@ -78,13 +78,19 @@
78 storage_->get_new_downloader(dir_name, file_name),78 storage_->get_new_downloader(dir_name, file_name),
79 std::function<void(std::shared_ptr<Downloader> const&)>{79 std::function<void(std::shared_ptr<Downloader> const&)>{
80 [this](std::shared_ptr<Downloader> const& downloader){80 [this](std::shared_ptr<Downloader> const& downloader){
81 int fd {-1};81 auto fd {-1};
82 if (downloader) {82 if (downloader) {
83 auto restore_helper = qSharedPointerDynamicCast<RestoreHelper>(helper_);83 auto restore_helper = qSharedPointerDynamicCast<RestoreHelper>(helper_);
84 restore_helper->set_downloader(downloader);84 restore_helper->set_downloader(downloader);
85 fd = restore_helper->get_helper_socket();85 fd = restore_helper->get_helper_socket();
86 }86 Q_EMIT(q_ptr->task_socket_ready(fd));
87 Q_EMIT(q_ptr->task_socket_ready(fd));87 }
88 else
89 {
90 error_ = storage_->get_last_error();
91 qDebug("Emitting task_socket_error(error=%d)", static_cast<int>(error_));
92 Q_EMIT(q_ptr->task_socket_error(error_));
93 }
88 }94 }
89 }95 }
90 );96 );
9197
=== modified file 'src/service/keeper-task.cpp'
--- src/service/keeper-task.cpp 2016-12-15 14:30:42 +0000
+++ src/service/keeper-task.cpp 2016-12-22 14:35:27 +0000
@@ -35,7 +35,7 @@
35 , task_data_(task_data)35 , task_data_(task_data)
36 , helper_registry_(helper_registry)36 , helper_registry_(helper_registry)
37 , storage_(storage)37 , storage_(storage)
38 , error_(keeper::KeeperError::OK)38 , error_(keeper::Error::OK)
39{39{
40}40}
4141
@@ -50,7 +50,7 @@
50 if (urls.isEmpty())50 if (urls.isEmpty())
51 {51 {
52 task_data_.action = helper_->to_string(Helper::State::FAILED);52 task_data_.action = helper_->to_string(Helper::State::FAILED);
53 error_ = keeper::KeeperError::HELPER_BAD_URL;53 error_ = keeper::Error::HELPER_BAD_URL;
54 qWarning() << QStringLiteral("Error: uuid %1 has no url").arg(task_data_.metadata.uuid());54 qWarning() << QStringLiteral("Error: uuid %1 has no url").arg(task_data_.metadata.uuid());
55 calculate_and_notify_state(Helper::State::FAILED);55 calculate_and_notify_state(Helper::State::FAILED);
56 return false;56 return false;
@@ -66,7 +66,7 @@
66 std::bind(&KeeperTaskPrivate::on_helper_percent_done_changed, this, std::placeholders::_1)66 std::bind(&KeeperTaskPrivate::on_helper_percent_done_changed, this, std::placeholders::_1)
67 );67 );
6868
69 QObject::connect(helper_.data(), &Helper::error, [this](keeper::KeeperError error){69 QObject::connect(helper_.data(), &Helper::error, [this](keeper::Error error){
70 error_ = error;70 error_ = error;
71 });71 });
7272
@@ -140,7 +140,7 @@
140 if (task_data_.action == "failed" || task_data_.action == "cancelled")140 if (task_data_.action == "failed" || task_data_.action == "cancelled")
141 {141 {
142 auto error = error_;142 auto error = error_;
143 if (task_data_.error != keeper::KeeperError::OK)143 if (task_data_.error != keeper::Error::OK)
144 {144 {
145 error = task_data_.error;145 error = task_data_.error;
146 }146 }
@@ -205,7 +205,7 @@
205 }205 }
206}206}
207207
208keeper::KeeperError KeeperTaskPrivate::error() const208keeper::Error KeeperTaskPrivate::error() const
209{209{
210 return error_;210 return error_;
211}211}
@@ -269,7 +269,7 @@
269 return d->to_string(state);269 return d->to_string(state);
270}270}
271271
272keeper::KeeperError KeeperTask::error() const272keeper::Error KeeperTask::error() const
273{273{
274 Q_D(const KeeperTask);274 Q_D(const KeeperTask);
275275
276276
=== modified file 'src/service/keeper-task.h'
--- src/service/keeper-task.h 2016-12-14 13:10:00 +0000
+++ src/service/keeper-task.h 2016-12-22 14:35:27 +0000
@@ -41,7 +41,7 @@
41 struct TaskData41 struct TaskData
42 {42 {
43 QString action;43 QString action;
44 keeper::KeeperError error;44 keeper::Error error;
45 Metadata metadata;45 Metadata metadata;
46 };46 };
4747
@@ -63,10 +63,11 @@
6363
64 QString to_string(Helper::State state);64 QString to_string(Helper::State state);
6565
66 keeper::KeeperError error() const;66 keeper::Error error() const;
67Q_SIGNALS:67Q_SIGNALS:
68 void task_state_changed(Helper::State state);68 void task_state_changed(Helper::State state);
69 void task_socket_ready(int socket_descriptor);69 void task_socket_ready(int socket_descriptor);
70 void task_socket_error(keeper::Error error);
7071
71protected:72protected:
72 KeeperTask(KeeperTaskPrivate & d, QObject *parent = nullptr);73 KeeperTask(KeeperTaskPrivate & d, QObject *parent = nullptr);
7374
=== modified file 'src/service/keeper-user.cpp'
--- src/service/keeper-user.cpp 2016-11-22 09:37:40 +0000
+++ src/service/keeper-user.cpp 2016-12-22 14:35:27 +0000
@@ -33,7 +33,7 @@
3333
34KeeperUser::~KeeperUser() =default;34KeeperUser::~KeeperUser() =default;
3535
36QVariantDictMap36keeper::KeeperItemsMap
37KeeperUser::GetBackupChoices()37KeeperUser::GetBackupChoices()
38{38{
39 auto bus = connection();39 auto bus = connection();
@@ -57,7 +57,7 @@
57 keeper_.cancel();57 keeper_.cancel();
58}58}
5959
60QVariantDictMap60keeper::KeeperItemsMap
61KeeperUser::GetRestoreChoices()61KeeperUser::GetRestoreChoices()
62{62{
63 Q_ASSERT(calledFromDBus());63 Q_ASSERT(calledFromDBus());
@@ -81,7 +81,7 @@
81 keeper_.start_tasks(keys, bus, msg);81 keeper_.start_tasks(keys, bus, msg);
82}82}
8383
84QVariantDictMap84keeper::KeeperItemsMap
85KeeperUser::get_state() const85KeeperUser::get_state() const
86{86{
87 return keeper_.get_state();87 return keeper_.get_state();
8888
=== modified file 'src/service/keeper-user.h'
--- src/service/keeper-user.h 2016-09-05 18:38:36 +0000
+++ src/service/keeper-user.h 2016-12-22 14:35:27 +0000
@@ -37,11 +37,11 @@
37 virtual ~KeeperUser();37 virtual ~KeeperUser();
38 Q_DISABLE_COPY(KeeperUser)38 Q_DISABLE_COPY(KeeperUser)
3939
40 Q_PROPERTY(QVariantDictMap State40 Q_PROPERTY(keeper::KeeperItemsMap State
41 READ get_state41 READ get_state
42 NOTIFY state_changed)42 NOTIFY state_changed)
4343
44 QVariantDictMap get_state() const;44 keeper::KeeperItemsMap get_state() const;
4545
46Q_SIGNALS:46Q_SIGNALS:
4747
@@ -49,10 +49,10 @@
4949
50public Q_SLOTS:50public Q_SLOTS:
5151
52 QVariantDictMap GetBackupChoices();52 keeper::KeeperItemsMap GetBackupChoices();
53 void StartBackup(const QStringList&);53 void StartBackup(const QStringList&);
5454
55 QVariantDictMap GetRestoreChoices();55 keeper::KeeperItemsMap GetRestoreChoices();
56 void StartRestore(const QStringList&);56 void StartRestore(const QStringList&);
5757
58 void Cancel();58 void Cancel();
5959
=== modified file 'src/service/keeper.cpp'
--- src/service/keeper.cpp 2016-12-01 14:18:57 +0000
+++ src/service/keeper.cpp 2016-12-22 14:35:27 +0000
@@ -46,12 +46,15 @@
46 return variants;46 return variants;
47 }47 }
4848
49 QVariantDictMap choices_to_variant_dict_map(const QVector<Metadata>& choices)49 keeper::KeeperItemsMap choices_to_variant_dict_map(const QVector<Metadata>& choices)
50 {50 {
51 QVariantDictMap ret;51 keeper::KeeperItemsMap ret;
5252
53 for (auto const& metadata : choices)53 for (auto const& metadata : choices)
54 ret.insert(metadata.uuid(), strings_to_variants(metadata.get_public_properties()));54 {
55 keeper::KeeperItem value(strings_to_variants(metadata.get_public_properties()));
56 ret.insert(metadata.uuid(), value);
57 }
5558
56 return ret;59 return ret;
57 }60 }
@@ -113,11 +116,7 @@
113 if (task_manager_.start_backup(tasks.values()))116 if (task_manager_.start_backup(tasks.values()))
114 unhandled.subtract(QSet<QString>::fromList(tasks.keys()));117 unhandled.subtract(QSet<QString>::fromList(tasks.keys()));
115118
116 check_for_unhandled_tasks(unhandled, bus, msg);119 check_for_unhandled_tasks_and_reply(unhandled, bus, msg);
117
118 // reply now to the dbus call
119 auto reply = msg.createReply();
120 bus.send(reply);
121 }120 }
122 else // restore121 else // restore
123 {122 {
@@ -125,19 +124,17 @@
125 connections_.connect_oneshot(124 connections_.connect_oneshot(
126 this,125 this,
127 &KeeperPrivate::restore_choices_ready,126 &KeeperPrivate::restore_choices_ready,
128 std::function<void()>{[this, uuids, msg, bus, get_tasks](){127 std::function<void(keeper::Error)>{[this, uuids, msg, bus, get_tasks](keeper::Error error){
129 qDebug() << "Choices ready";128 qDebug() << "Choices ready";
130 auto unhandled = QSet<QString>::fromList(uuids);129 auto unhandled = QSet<QString>::fromList(uuids);
131 auto restore_tasks = get_tasks(cached_restore_choices_, uuids);130 if (error == keeper::Error::OK)
132 qDebug() << "After getting tasks...";131 {
133 if (!restore_tasks.empty() && task_manager_.start_restore(restore_tasks.values()))132 auto restore_tasks = get_tasks(cached_restore_choices_, uuids);
134 unhandled.subtract(QSet<QString>::fromList(restore_tasks.keys()));133 qDebug() << "After getting tasks...";
135134 if (!restore_tasks.empty() && task_manager_.start_restore(restore_tasks.values()))
136 check_for_unhandled_tasks(unhandled, bus, msg);135 unhandled.subtract(QSet<QString>::fromList(restore_tasks.keys()));
137136 }
138 // reply now to the dbus call137 check_for_unhandled_tasks_and_reply(unhandled, bus, msg);
139 auto reply = msg.createReply();
140 bus.send(reply);
141 }}138 }}
142 );139 );
143 get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);140 get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);
@@ -149,18 +146,19 @@
149 msg.setDelayedReply(true);146 msg.setDelayedReply(true);
150 }147 }
151148
152 void emit_choices_ready(ChoicesType type)149 void emit_choices_ready(ChoicesType type, keeper::Error error)
153 {150 {
154 switch(type)151 switch(type)
155 {152 {
156 case KeeperPrivate::ChoicesType::BACKUP_CHOICES:153 case KeeperPrivate::ChoicesType::BACKUP_CHOICES:
157 Q_EMIT(backup_choices_ready());154 Q_EMIT(backup_choices_ready(error));
158 break;155 break;
159 case KeeperPrivate::ChoicesType::RESTORES_CHOICES:156 case KeeperPrivate::ChoicesType::RESTORES_CHOICES:
160 Q_EMIT(restore_choices_ready());157 Q_EMIT(restore_choices_ready(error));
161 break;158 break;
162 }159 }
163 }160 }
161
164 void get_choices(const QSharedPointer<MetadataProvider> & provider, ChoicesType type)162 void get_choices(const QSharedPointer<MetadataProvider> & provider, ChoicesType type)
165 {163 {
166 bool check_empty = (type == KeeperPrivate::ChoicesType::BACKUP_CHOICES)164 bool check_empty = (type == KeeperPrivate::ChoicesType::BACKUP_CHOICES)
@@ -170,71 +168,94 @@
170 connections_.connect_oneshot(168 connections_.connect_oneshot(
171 provider.data(),169 provider.data(),
172 &MetadataProvider::finished,170 &MetadataProvider::finished,
173 std::function<void()>{[this, provider, type](){171 std::function<void(keeper::Error)>{[this, provider, type](keeper::Error error){
174 qDebug() << "Get choices finished";172 qDebug() << "Get choices finished";
175 switch (type)173 if (error == keeper::Error::OK)
176 {174 {
177 case KeeperPrivate::ChoicesType::BACKUP_CHOICES:175 switch (type)
178 cached_backup_choices_ = provider->get_backups();176 {
179 break;177 case KeeperPrivate::ChoicesType::BACKUP_CHOICES:
180 case KeeperPrivate::ChoicesType::RESTORES_CHOICES:178 cached_backup_choices_ = provider->get_backups();
181 cached_restore_choices_ = provider->get_backups();179 break;
182 break;180 case KeeperPrivate::ChoicesType::RESTORES_CHOICES:
183 };181 cached_restore_choices_ = provider->get_backups();
184 emit_choices_ready(type);182 break;
183 }
184 }
185 emit_choices_ready(type, error);
185 }}186 }}
186 );187 );
187
188 provider->get_backups_async();188 provider->get_backups_async();
189 }189 }
190 else190 else
191 {191 {
192 emit_choices_ready(type);192 emit_choices_ready(type, keeper::Error::OK);
193 }193 }
194 }194 }
195195
196 QVariantDictMap get_backup_choices_var_dict_map(QDBusConnection bus,196 keeper::KeeperItemsMap get_backup_choices_var_dict_map(QDBusConnection bus,
197 QDBusMessage const & msg)197 QDBusMessage const & msg)
198 {198 {
199 connections_.connect_oneshot(199 connections_.connect_oneshot(
200 this,200 this,
201 &KeeperPrivate::backup_choices_ready,201 &KeeperPrivate::backup_choices_ready,
202 std::function<void()>{[this, msg, bus](){202 std::function<void(keeper::Error)>{[this, msg, bus](keeper::Error error){
203 qDebug() << "Backup choices are ready";203 qDebug() << "Backup choices are ready";
204 // reply now to the dbus call204 if (error == keeper::Error::OK)
205 auto reply = msg.createReply();205 {
206 reply << QVariant::fromValue(choices_to_variant_dict_map(cached_backup_choices_));206 // reply now to the dbus call
207 bus.send(reply);207 auto reply = msg.createReply();
208 reply << QVariant::fromValue(choices_to_variant_dict_map(cached_backup_choices_));
209 bus.send(reply);
210 }
211 else
212 {
213 auto message = QStringLiteral("Error obtaining backup choices, keeper returned error: %1").arg(static_cast<int>(error));
214 qWarning() << message;
215 auto reply = msg.createErrorReply(QDBusError::Failed, message);
216 reply << QVariant::fromValue(error);
217 bus.send(reply);
218 }
208 }}219 }}
209 );220 );
210
211 get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);221 get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);
212 msg.setDelayedReply(true);222 msg.setDelayedReply(true);
213 return QVariantDictMap();223 return keeper::KeeperItemsMap();
214 }224 }
215225
216 QVariantDictMap get_restore_choices_var_dict_map(QDBusConnection bus,226 keeper::KeeperItemsMap get_restore_choices_var_dict_map(QDBusConnection bus,
217 QDBusMessage const & msg)227 QDBusMessage const & msg)
218 {228 {
229 qDebug() << "Getting restores --------------------------------";
219 cached_restore_choices_.clear();230 cached_restore_choices_.clear();
220 connections_.connect_oneshot(231 connections_.connect_oneshot(
221 this,232 this,
222 &KeeperPrivate::restore_choices_ready,233 &KeeperPrivate::restore_choices_ready,
223 std::function<void()>{[this, msg, bus](){234 std::function<void(keeper::Error)>{[this, msg, bus](keeper::Error error){
224 qDebug() << "Restore choices are ready";235 qDebug() << "Restore choices are ready";
225 // reply now to the dbus call236 if (error == keeper::Error::OK)
226 auto reply = msg.createReply();237 {
227 reply << QVariant::fromValue(choices_to_variant_dict_map(cached_restore_choices_));238 // reply now to the dbus call
228 bus.send(reply);239 auto reply = msg.createReply();
240 reply << QVariant::fromValue(choices_to_variant_dict_map(cached_restore_choices_));
241 bus.send(reply);
242 }
243 else
244 {
245 auto message = QStringLiteral("Error obtaining restore choices, keeper returned error: %1").arg(static_cast<int>(error));
246 qWarning() << message;
247 auto reply = msg.createErrorReply(QDBusError::Failed, message);
248 reply << QVariant::fromValue(error);
249 bus.send(reply);
250 }
229 }}251 }}
230 );252 );
231
232 get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);253 get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);
233 msg.setDelayedReply(true);254 msg.setDelayedReply(true);
234 return QVariantDictMap();255 return keeper::KeeperItemsMap();
235 }256 }
236257
237 QVariantDictMap get_state() const258 keeper::KeeperItemsMap get_state() const
238 {259 {
239 return task_manager_.get_state();260 return task_manager_.get_state();
240 }261 }
@@ -258,6 +279,17 @@
258 }279 }
259 );280 );
260281
282 connections_.connect_oneshot(
283 &task_manager_,
284 &TaskManager::socket_error,
285 std::function<void(keeper::Error)>{
286 [bus,msg](keeper::Error error){
287 qDebug("BackupManager returned socket error: %d", static_cast<int>(error));
288 bus.send(msg.createErrorReply(QDBusError::InvalidArgs, "Error obtaining remote backup socket"));
289 }
290 }
291 );
292
261 qDebug() << "Asking for a storage framework socket from the task manager";293 qDebug() << "Asking for a storage framework socket from the task manager";
262 task_manager_.ask_for_uploader(n_bytes);294 task_manager_.ask_for_uploader(n_bytes);
263295
@@ -286,6 +318,17 @@
286 }318 }
287 );319 );
288320
321 connections_.connect_oneshot(
322 &task_manager_,
323 &TaskManager::socket_error,
324 std::function<void(keeper::Error)>{
325 [bus,msg](keeper::Error error){
326 qDebug("RestoreManager returned socket error: %d", static_cast<int>(error));
327 bus.send(msg.createErrorReply(QDBusError::InvalidArgs, "Error obtaining remote restore socket"));
328 }
329 }
330 );
331
289 qDebug() << "Asking for a storage framework socket from the task manager";332 qDebug() << "Asking for a storage framework socket from the task manager";
290 task_manager_.ask_for_downloader();333 task_manager_.ask_for_downloader();
291334
@@ -305,11 +348,10 @@
305 }348 }
306349
307Q_SIGNALS:350Q_SIGNALS:
308 void backup_choices_ready();351 void backup_choices_ready(keeper::Error error);
309 void restore_choices_ready();352 void restore_choices_ready(keeper::Error error);
310353
311private:354private:
312
313 void on_task_manager_finished()355 void on_task_manager_finished()
314 {356 {
315 // force a backup choices regeneration to avoid repeating uuids357 // force a backup choices regeneration to avoid repeating uuids
@@ -317,7 +359,7 @@
317 invalidate_choices_cache();359 invalidate_choices_cache();
318 }360 }
319361
320 void check_for_unhandled_tasks(QSet<QString> const & unhandled,362 void check_for_unhandled_tasks_and_reply(QSet<QString> const & unhandled,
321 QDBusConnection bus,363 QDBusConnection bus,
322 QDBusMessage const & msg )364 QDBusMessage const & msg )
323 {365 {
@@ -329,6 +371,9 @@
329 text += ' ' + uuid;371 text += ' ' + uuid;
330 bus.send(msg.createErrorReply(QDBusError::InvalidArgs, text));372 bus.send(msg.createErrorReply(QDBusError::InvalidArgs, text));
331 }373 }
374
375 auto reply = msg.createReply();
376 bus.send(reply);
332 }377 }
333378
334 Keeper * const q_ptr;379 Keeper * const q_ptr;
@@ -383,7 +428,7 @@
383 return d->start_restore(bus, msg);428 return d->start_restore(bus, msg);
384}429}
385430
386QVariantDictMap431keeper::KeeperItemsMap
387Keeper::get_backup_choices_var_dict_map(QDBusConnection bus,432Keeper::get_backup_choices_var_dict_map(QDBusConnection bus,
388 QDBusMessage const & msg)433 QDBusMessage const & msg)
389{434{
@@ -392,7 +437,7 @@
392 return d->get_backup_choices_var_dict_map(bus, msg);437 return d->get_backup_choices_var_dict_map(bus, msg);
393}438}
394439
395QVariantDictMap440keeper::KeeperItemsMap
396Keeper::get_restore_choices(QDBusConnection bus,441Keeper::get_restore_choices(QDBusConnection bus,
397 QDBusMessage const & msg)442 QDBusMessage const & msg)
398{443{
@@ -401,7 +446,7 @@
401 return d->get_restore_choices_var_dict_map(bus,msg);446 return d->get_restore_choices_var_dict_map(bus,msg);
402}447}
403448
404QVariantDictMap449keeper::KeeperItemsMap
405Keeper::get_state() const450Keeper::get_state() const
406{451{
407 Q_D(const Keeper);452 Q_D(const Keeper);
408453
=== modified file 'src/service/keeper.h'
--- src/service/keeper.h 2016-11-22 09:37:40 +0000
+++ src/service/keeper.h 2016-12-22 14:35:27 +0000
@@ -52,8 +52,8 @@
5252
53 virtual ~Keeper();53 virtual ~Keeper();
5454
55 QVariantDictMap get_backup_choices_var_dict_map(QDBusConnection bus, QDBusMessage const & msg);55 keeper::KeeperItemsMap get_backup_choices_var_dict_map(QDBusConnection bus, QDBusMessage const & msg);
56 QVariantDictMap get_restore_choices(QDBusConnection bus, QDBusMessage const & msg);56 keeper::KeeperItemsMap get_restore_choices(QDBusConnection bus, QDBusMessage const & msg);
5757
58 QDBusUnixFileDescriptor StartBackup(QDBusConnection,58 QDBusUnixFileDescriptor StartBackup(QDBusConnection,
59 QDBusMessage const & message,59 QDBusMessage const & message,
@@ -67,7 +67,7 @@
67 QDBusConnection bus,67 QDBusConnection bus,
68 QDBusMessage const & msg);68 QDBusMessage const & msg);
6969
70 QVariantDictMap get_state() const;70 keeper::KeeperItemsMap get_state() const;
7171
72 void cancel();72 void cancel();
7373
7474
=== modified file 'src/service/metadata-provider.h'
--- src/service/metadata-provider.h 2016-10-28 15:11:21 +0000
+++ src/service/metadata-provider.h 2016-12-22 14:35:27 +0000
@@ -19,6 +19,7 @@
1919
20#pragma once20#pragma once
2121
22#include "client/keeper-errors.h"
22#include "helper/metadata.h"23#include "helper/metadata.h"
2324
24#include <QObject>25#include <QObject>
@@ -33,7 +34,7 @@
33 virtual void get_backups_async() =0;34 virtual void get_backups_async() =0;
3435
35Q_SIGNALS:36Q_SIGNALS:
36 void finished();37 void finished(keeper::Error error);
3738
38protected:39protected:
39 explicit MetadataProvider(QObject *parent = nullptr) : QObject(parent){};40 explicit MetadataProvider(QObject *parent = nullptr) : QObject(parent){};
4041
=== modified file 'src/service/private/keeper-task_p.h'
--- src/service/private/keeper-task_p.h 2016-12-14 11:00:21 +0000
+++ src/service/private/keeper-task_p.h 2016-12-22 14:35:27 +0000
@@ -42,7 +42,7 @@
4242
43 QString to_string(Helper::State state);43 QString to_string(Helper::State state);
4444
45 keeper::KeeperError error() const;45 keeper::Error error() const;
4646
47protected:47protected:
48 void set_current_task_action(QString const& action);48 void set_current_task_action(QString const& action);
@@ -60,5 +60,5 @@
60 QSharedPointer<StorageFrameworkClient> storage_;60 QSharedPointer<StorageFrameworkClient> storage_;
61 QSharedPointer<Helper> helper_;61 QSharedPointer<Helper> helper_;
62 QVariantMap state_;62 QVariantMap state_;
63 keeper::KeeperError error_;63 keeper::Error error_;
64};64};
6565
=== modified file 'src/service/restore-choices.cpp'
--- src/service/restore-choices.cpp 2016-12-15 14:30:42 +0000
+++ src/service/restore-choices.cpp 2016-12-22 14:35:27 +0000
@@ -67,7 +67,7 @@
67 manifests_to_read_--;67 manifests_to_read_--;
68 if (!manifests_to_read_)68 if (!manifests_to_read_)
69 {69 {
70 Q_EMIT(finished());70 Q_EMIT(finished(keeper::Error::OK));
71 }71 }
72 }}72 }}
73 );73 );
@@ -76,8 +76,8 @@
76 }76 }
77 else77 else
78 {78 {
79 qWarning() << "We could not find and keeper backup when retrieving restore options.";79 qWarning() << "We could not find and keeper backups directory when retrieving restore options.";
80 Q_EMIT(finished());80 Q_EMIT(finished(storage_->get_last_error()));
81 }81 }
82 }82 }
83 }83 }
8484
=== modified file 'src/service/task-manager.cpp'
--- src/service/task-manager.cpp 2016-12-14 11:00:21 +0000
+++ src/service/task-manager.cpp 2016-12-22 14:35:27 +0000
@@ -59,9 +59,21 @@
59 *** State public59 *** State public
60 ***/60 ***/
6161
62 QVariantDictMap get_state() const62 keeper::KeeperItemsMap get_converted_state_to_user_type() const
63 {63 {
64 return state_;64 keeper::KeeperItemsMap ret;
65 for (auto iter = state_.begin(); iter != state_.end(); ++iter)
66 {
67 keeper::KeeperItem item((*iter));
68 ret[iter.key()] = item;
69 }
70 return ret;
71 }
72
73 keeper::KeeperItemsMap get_state() const
74 {
75 return get_converted_state_to_user_type();
76// return state_;
65 }77 }
6678
67 void ask_for_uploader(quint64 n_bytes)79 void ask_for_uploader(quint64 n_bytes)
@@ -147,7 +159,7 @@
147 auto& td = task_data_[uuid];159 auto& td = task_data_[uuid];
148 td.metadata = metadata;160 td.metadata = metadata;
149 td.action = QStringLiteral("queued"); // TODO i18n161 td.action = QStringLiteral("queued"); // TODO i18n
150 td.error = keeper::KeeperError::OK;162 td.error = keeper::Error::OK;
151 set_initial_task_state(td);163 set_initial_task_state(td);
152 }164 }
153165
@@ -170,7 +182,7 @@
170 }182 }
171 else183 else
172 {184 {
173 td.error = keeper::KeeperError::MANIFEST_STORAGE_ERROR;185 td.error = keeper::Error::MANIFEST_STORAGE;
174 set_current_task_action(task_->to_string(Helper::State::FAILED));186 set_current_task_action(task_->to_string(Helper::State::FAILED));
175 }187 }
176 active_manifest_.reset();188 active_manifest_.reset();
@@ -266,9 +278,25 @@
266 std::bind(&TaskManager::socket_ready, q_ptr, std::placeholders::_1)278 std::bind(&TaskManager::socket_ready, q_ptr, std::placeholders::_1)
267 );279 );
268280
281 QObject::connect(task_.data(), &KeeperTask::task_socket_error,
282 std::bind(&TaskManagerPrivate::on_task_socket_error, this, std::placeholders::_1)
283 );
284
269 return task_->start();285 return task_->start();
270 }286 }
271287
288 void on_task_socket_error(keeper::Error error)
289 {
290 if (!task_)
291 {
292 qWarning() << "Error updating current task state";
293 }
294 auto& td = task_data_[current_task_];
295 td.error = error;
296 set_current_task_action(task_->to_string(Helper::State::FAILED));
297 Q_EMIT(q_ptr->socket_error(error));
298 }
299
272 void set_current_task(QString const& uuid)300 void set_current_task(QString const& uuid)
273 {301 {
274 auto const prev = current_task_;302 auto const prev = current_task_;
@@ -409,7 +437,7 @@
409 return d->start_restore(tasks);437 return d->start_restore(tasks);
410}438}
411439
412QVariantDictMap TaskManager::get_state() const440keeper::KeeperItemsMap TaskManager::get_state() const
413{441{
414 Q_D(const TaskManager);442 Q_D(const TaskManager);
415443
416444
=== modified file 'src/service/task-manager.h'
--- src/service/task-manager.h 2016-12-01 14:18:57 +0000
+++ src/service/task-manager.h 2016-12-22 14:35:27 +0000
@@ -45,7 +45,7 @@
4545
46 Q_DISABLE_COPY(TaskManager)46 Q_DISABLE_COPY(TaskManager)
4747
48 Q_PROPERTY(QVariantDictMap State48 Q_PROPERTY(keeper::KeeperItemsMap State
49 READ get_state49 READ get_state
50 NOTIFY state_changed)50 NOTIFY state_changed)
5151
@@ -54,7 +54,7 @@
5454
55 bool start_restore(QList<Metadata> const& tasks);55 bool start_restore(QList<Metadata> const& tasks);
5656
57 QVariantDictMap get_state() const;57 keeper::KeeperItemsMap get_state() const;
5858
59 void ask_for_uploader(quint64 n_bytes);59 void ask_for_uploader(quint64 n_bytes);
6060
@@ -64,6 +64,7 @@
6464
65Q_SIGNALS:65Q_SIGNALS:
66 void socket_ready(int reply);66 void socket_ready(int reply);
67 void socket_error(keeper::Error error);
67 void state_changed();68 void state_changed();
68 void finished();69 void finished();
6970
7071
=== modified file 'src/storage-framework/storage_framework_client.cpp'
--- src/storage-framework/storage_framework_client.cpp 2016-12-15 14:30:42 +0000
+++ src/storage-framework/storage_framework_client.cpp 2016-12-22 14:35:27 +0000
@@ -55,6 +55,7 @@
55 if (choices.empty())55 if (choices.empty())
56 {56 {
57 qWarning() << "no storage-framework accounts to pick from";57 qWarning() << "no storage-framework accounts to pick from";
58 last_error_ = keeper::Error::NO_REMOTE_ACCOUNTS;
58 }59 }
59 else // for now just pick the first one. FIXME60 else // for now just pick the first one. FIXME
60 {61 {
@@ -73,6 +74,7 @@
73 if (choices.empty())74 if (choices.empty())
74 {75 {
75 qWarning() << "no storage-framework roots to pick from";76 qWarning() << "no storage-framework roots to pick from";
77 last_error_ = keeper::Error::NO_REMOTE_ROOTS;
76 }78 }
77 else // for now just pick the first one. FIXME79 else // for now just pick the first one. FIXME
78 {80 {
@@ -106,6 +108,8 @@
106QFuture<std::shared_ptr<Uploader>>108QFuture<std::shared_ptr<Uploader>>
107StorageFrameworkClient::get_new_uploader(int64_t n_bytes, QString const & dir_name, QString const & file_name)109StorageFrameworkClient::get_new_uploader(int64_t n_bytes, QString const & dir_name, QString const & file_name)
108{110{
111 clear_last_error();
112
109 QFutureInterface<std::shared_ptr<Uploader>> fi;113 QFutureInterface<std::shared_ptr<Uploader>> fi;
110114
111 add_roots_task([this, fi, n_bytes, dir_name, file_name](QVector<sf::Root::SPtr> const& roots)115 add_roots_task([this, fi, n_bytes, dir_name, file_name](QVector<sf::Root::SPtr> const& roots)
@@ -133,12 +137,17 @@
133 [this, fi, keeper_folder](std::shared_ptr<sf::Uploader> const& sf_uploader){137 [this, fi, keeper_folder](std::shared_ptr<sf::Uploader> const& sf_uploader){
134 qDebug() << "keeper_root->create_file() finished";138 qDebug() << "keeper_root->create_file() finished";
135 std::shared_ptr<Uploader> ret;139 std::shared_ptr<Uploader> ret;
136 if (sf_uploader) {140 if (sf_uploader)
141 {
137 ret.reset(142 ret.reset(
138 new StorageFrameworkUploader(sf_uploader, this),143 new StorageFrameworkUploader(sf_uploader, this),
139 [](Uploader* u){u->deleteLater();}144 [](Uploader* u){u->deleteLater();}
140 );145 );
141 }146 }
147 else
148 {
149 last_error_ = keeper::Error::CREATING_REMOTE_FILE;
150 }
142 QFutureInterface<decltype(ret)> qfi(fi);151 QFutureInterface<decltype(ret)> qfi(fi);
143 qfi.reportResult(ret);152 qfi.reportResult(ret);
144 qfi.reportFinished();153 qfi.reportFinished();
@@ -150,6 +159,13 @@
150 }159 }
151 );160 );
152 }161 }
162 else
163 {
164 std::shared_ptr<Uploader> ret;
165 QFutureInterface<decltype(ret)> qfi(fi);
166 qfi.reportResult(ret);
167 qfi.reportFinished();
168 }
153 });169 });
154170
155 return fi.future();171 return fi.future();
@@ -158,6 +174,8 @@
158QFuture<std::shared_ptr<Downloader>>174QFuture<std::shared_ptr<Downloader>>
159StorageFrameworkClient::get_new_downloader(QString const & dir_name, QString const & file_name)175StorageFrameworkClient::get_new_downloader(QString const & dir_name, QString const & file_name)
160{176{
177 clear_last_error();
178
161 QFutureInterface<std::shared_ptr<Downloader>> fi;179 QFutureInterface<std::shared_ptr<Downloader>> fi;
162180
163 add_roots_task([this, fi, dir_name, file_name](QVector<sf::Root::SPtr> const& roots)181 add_roots_task([this, fi, dir_name, file_name](QVector<sf::Root::SPtr> const& roots)
@@ -197,6 +215,10 @@
197 [](Downloader* d){d->deleteLater();}215 [](Downloader* d){d->deleteLater();}
198 );216 );
199 }217 }
218 else
219 {
220 last_error_ = keeper::Error::READING_REMOTE_FILE;
221 }
200 QFutureInterface<decltype(ret)> qfi(fi);222 QFutureInterface<decltype(ret)> qfi(fi);
201 qfi.reportResult(ret);223 qfi.reportResult(ret);
202 qfi.reportFinished();224 qfi.reportFinished();
@@ -204,6 +226,7 @@
204 }226 }
205 );227 );
206 } else {228 } else {
229 last_error_ = keeper::Error::READING_REMOTE_FILE;
207 std::shared_ptr<Downloader> ret_null;230 std::shared_ptr<Downloader> ret_null;
208 QFutureInterface<decltype(ret_null)> qfi(fi);231 QFutureInterface<decltype(ret_null)> qfi(fi);
209 qfi.reportResult(ret_null);232 qfi.reportResult(ret_null);
@@ -217,6 +240,13 @@
217 }240 }
218 );241 );
219 }242 }
243 else
244 {
245 std::shared_ptr<Downloader> ret;
246 QFutureInterface<decltype(ret)> qfi(fi);
247 qfi.reportResult(ret);
248 qfi.reportFinished();
249 }
220 });250 });
221251
222 return fi.future();252 return fi.future();
@@ -225,6 +255,8 @@
225QFuture<QVector<QString>>255QFuture<QVector<QString>>
226StorageFrameworkClient::get_keeper_dirs()256StorageFrameworkClient::get_keeper_dirs()
227{257{
258 clear_last_error();
259
228 QFutureInterface<QVector<QString>> fi;260 QFutureInterface<QVector<QString>> fi;
229261
230 add_roots_task([this, fi](QVector<sf::Root::SPtr> const& roots)262 add_roots_task([this, fi](QVector<sf::Root::SPtr> const& roots)
@@ -262,10 +294,23 @@
262 }294 }
263 );295 );
264 }296 }
297 else
298 {
299 QVector<QString> res;
300 QFutureInterface<decltype(res)> qfi(fi);
301 qfi.reportResult(res);
302 qfi.reportFinished();
303 }
265 });304 });
266 return fi.future();305 return fi.future();
267}306}
268307
308keeper::Error
309StorageFrameworkClient::get_last_error() const
310{
311 return last_error_;
312}
313
269QFuture<sf::Folder::SPtr>314QFuture<sf::Folder::SPtr>
270StorageFrameworkClient::get_keeper_folder(sf::Folder::SPtr const & root, QString const & dir_name, bool create_if_not_exists)315StorageFrameworkClient::get_keeper_folder(sf::Folder::SPtr const & root, QString const & dir_name, bool create_if_not_exists)
271{316{
@@ -335,6 +380,7 @@
335 QFutureInterface<decltype(res)> qfi(fi);380 QFutureInterface<decltype(res)> qfi(fi);
336 qfi.reportResult(res);381 qfi.reportResult(res);
337 qfi.reportFinished();382 qfi.reportFinished();
383 last_error_ = keeper::Error::REMOTE_DIR_NOT_EXISTS;
338 }384 }
339 else385 else
340 {386 {
@@ -343,6 +389,10 @@
343 root->create_folder(dir_name),389 root->create_folder(dir_name),
344 std::function<void(sf::Folder::SPtr const &)>{390 std::function<void(sf::Folder::SPtr const &)>{
345 [this, fi, res, root](sf::Folder::SPtr const & folder){391 [this, fi, res, root](sf::Folder::SPtr const & folder){
392 if (!folder)
393 {
394 last_error_ = keeper::Error::CREATING_REMOTE_DIR;
395 }
346 QFutureInterface<decltype(res)> qfi(fi);396 QFutureInterface<decltype(res)> qfi(fi);
347 qfi.reportResult(folder);397 qfi.reportResult(folder);
348 qfi.reportFinished();398 qfi.reportFinished();
@@ -421,3 +471,9 @@
421471
422 return fi.future();472 return fi.future();
423}473}
474
475void
476StorageFrameworkClient::clear_last_error()
477{
478 last_error_ = keeper::Error::OK;
479}
424480
=== modified file 'src/storage-framework/storage_framework_client.h'
--- src/storage-framework/storage_framework_client.h 2016-11-11 14:50:06 +0000
+++ src/storage-framework/storage_framework_client.h 2016-12-22 14:35:27 +0000
@@ -20,6 +20,7 @@
2020
21#pragma once21#pragma once
2222
23#include "client/keeper-errors.h"
23#include "util/connection-helper.h"24#include "util/connection-helper.h"
24#include "storage-framework/uploader.h"25#include "storage-framework/uploader.h"
25#include "storage-framework/downloader.h"26#include "storage-framework/downloader.h"
@@ -46,6 +47,7 @@
46 QFuture<std::shared_ptr<Uploader>> get_new_uploader(int64_t n_bytes, QString const & dir_name, QString const & file_name);47 QFuture<std::shared_ptr<Uploader>> get_new_uploader(int64_t n_bytes, QString const & dir_name, QString const & file_name);
47 QFuture<std::shared_ptr<Downloader>> get_new_downloader(QString const & dir_name, QString const & file_name);48 QFuture<std::shared_ptr<Downloader>> get_new_downloader(QString const & dir_name, QString const & file_name);
48 QFuture<QVector<QString>> get_keeper_dirs();49 QFuture<QVector<QString>> get_keeper_dirs();
50 keeper::Error get_last_error() const;
4951
50 static QString const KEEPER_FOLDER;52 static QString const KEEPER_FOLDER;
51private:53private:
@@ -61,6 +63,9 @@
61 QFuture<unity::storage::qt::client::File::SPtr> get_storage_framework_file(unity::storage::qt::client::Folder::SPtr const & root, QString const & file_name);63 QFuture<unity::storage::qt::client::File::SPtr> get_storage_framework_file(unity::storage::qt::client::Folder::SPtr const & root, QString const & file_name);
62 QFuture<QVector<QString>> get_storage_framework_dirs(unity::storage::qt::client::Folder::SPtr const & root);64 QFuture<QVector<QString>> get_storage_framework_dirs(unity::storage::qt::client::Folder::SPtr const & root);
6365
66 void clear_last_error();
67
64 unity::storage::qt::client::Runtime::SPtr runtime_;68 unity::storage::qt::client::Runtime::SPtr runtime_;
65 ConnectionHelper connection_helper_;69 ConnectionHelper connection_helper_;
70 mutable keeper::Error last_error_ = keeper::Error::OK;
66};71};
6772
=== modified file 'tests/dbusmock/keeper-template-test.cpp'
--- tests/dbusmock/keeper-template-test.cpp 2016-08-01 19:34:24 +0000
+++ tests/dbusmock/keeper-template-test.cpp 2016-12-22 14:35:27 +0000
@@ -59,105 +59,114 @@
59 EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());59 EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());
6060
61 // ask for a list of backup choices61 // ask for a list of backup choices
62 QDBusReply<QVariantDictMap> choices = user_iface_->call("GetBackupChoices");62 QDBusPendingReply<keeper::KeeperItemsMap> choices_reply = user_iface_->call("GetBackupChoices");
63 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());63 choices_reply.waitForFinished();
6464 if (!choices_reply.isValid())
65 // check the results65 {
66 const auto expected_choices = QVariantDictMap{{uuid, props}};66 qDebug() << "-------------------" << choices_reply.error().message();
67 ASSERT_EQ(expected_choices, choices);67 }
68}68 EXPECT_TRUE(choices_reply.isValid()) << qPrintable(choices_reply.error().message());
6969
7070 auto choices = choices_reply.value();
71// test that StartBackup() fails if we pass an invalid arg71 // check the results
72TEST_F(KeeperTemplateTest, StartBackupWithInvalidArg)72 const auto expected_choices = QVariantDictMap{{uuid, props}};
73{73 auto iter = choices.find(uuid);
74 const auto invalid_uuid = QUuid::createUuid().toString();74 ASSERT_NE(iter, choices.end());
7575
76 QDBusReply<void> reply = user_iface_->call("StartBackup", QStringList{invalid_uuid});76 ASSERT_EQ((*iter), props);
77 EXPECT_FALSE(reply.isValid());77}
78 EXPECT_EQ(QDBusError::InvalidArgs, reply.error().type());78
79}79
8080//// test that StartBackup() fails if we pass an invalid arg
8181//TEST_F(KeeperTemplateTest, StartBackupWithInvalidArg)
82// test GetRestoreChoices() returns what we give to AddRestoreChoice()82//{
83TEST_F(KeeperTemplateTest, RestoreChoices)83// const auto invalid_uuid = QUuid::createUuid().toString();
84{84//
85 // build a restore choice85// QDBusReply<void> reply = user_iface_->call("StartBackup", QStringList{invalid_uuid});
86 const auto uuid = QUuid::createUuid().toString();86// EXPECT_FALSE(reply.isValid());
87 const auto blob = QUuid::createUuid().toByteArray();87// EXPECT_EQ(QDBusError::InvalidArgs, reply.error().type());
88 const QMap<QString,QVariant> props {88//}
89 { KEY_NAME, QStringLiteral("some-name") },89//
90 { KEY_TYPE, QStringLiteral("some-type") },90//
91 { KEY_SUBTYPE, QStringLiteral("some-subtype") },91//// test GetRestoreChoices() returns what we give to AddRestoreChoice()
92 { KEY_HELPER, QString::fromUtf8("/dev/null") },92//TEST_F(KeeperTemplateTest, RestoreChoices)
93 { KEY_SIZE, quint64(blob.size()) },93//{
94 { KEY_CTIME, quint64(time(nullptr)) },94// // build a restore choice
95 { KEY_BLOB, blob }95// const auto uuid = QUuid::createUuid().toString();
96 };96// const auto blob = QUuid::createUuid().toByteArray();
9797// const QMap<QString,QVariant> props {
98 // add it98// { KEY_NAME, QStringLiteral("some-name") },
99 auto msg = mock_iface_->call(QStringLiteral("AddRestoreChoice"), uuid, props);99// { KEY_TYPE, QStringLiteral("some-type") },
100 EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());100// { KEY_SUBTYPE, QStringLiteral("some-subtype") },
101101// { KEY_HELPER, QString::fromUtf8("/dev/null") },
102 // ask for a list of restore choices102// { KEY_SIZE, quint64(blob.size()) },
103 QDBusReply<QVariantDictMap> choices = user_iface_->call("GetRestoreChoices");103// { KEY_CTIME, quint64(time(nullptr)) },
104 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());104// { KEY_BLOB, blob }
105105// };
106 // check the results106//
107 const auto expected_choices = QVariantDictMap{{uuid, props}};107// // add it
108 ASSERT_EQ(expected_choices, choices);108// auto msg = mock_iface_->call(QStringLiteral("AddRestoreChoice"), uuid, props);
109}109// EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());
110110//
111111// // ask for a list of restore choices
112// test that StartRestore() fails if we pass an invalid arg112// QDBusReply<QVariantDictMap> choices = user_iface_->call("GetRestoreChoices");
113TEST_F(KeeperTemplateTest, StartRestoreWithInvalidArg)113// EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
114{114//
115 const auto invalid_uuid = QUuid::createUuid().toString();115// // check the results
116116// const auto expected_choices = QVariantDictMap{{uuid, props}};
117 QDBusReply<void> reply = user_iface_->call("StartRestore", QStringList{invalid_uuid});117// ASSERT_EQ(expected_choices, choices);
118 EXPECT_FALSE(reply.isValid());118//}
119 EXPECT_EQ(QDBusError::InvalidArgs, reply.error().type());119//
120}120//
121121//// test that StartRestore() fails if we pass an invalid arg
122122//TEST_F(KeeperTemplateTest, StartRestoreWithInvalidArg)
123// test that Status() returns empty if we haven't done anything yet123//{
124TEST_F(KeeperTemplateTest, TestEmptyStatus)124// const auto invalid_uuid = QUuid::createUuid().toString();
125{125//
126 EXPECT_TRUE(user_iface_->state().isEmpty());126// QDBusReply<void> reply = user_iface_->call("StartRestore", QStringList{invalid_uuid});
127}127// EXPECT_FALSE(reply.isValid());
128128// EXPECT_EQ(QDBusError::InvalidArgs, reply.error().type());
129129//}
130/***130//
131**** Make a real backup131//
132***/132//// test that Status() returns empty if we haven't done anything yet
133133//TEST_F(KeeperTemplateTest, TestEmptyStatus)
134TEST_F(KeeperTemplateTest, BackupRun)134//{
135{135// EXPECT_TRUE(user_iface_->state().isEmpty());
136 QTemporaryDir sandbox;136//}
137137//
138 // build a backup choice138//
139 const auto uuid = QUuid::createUuid().toString();139///***
140 const QMap<QString,QVariant> props {140//**** Make a real backup
141 { KEY_NAME, QStringLiteral("Music") },141//***/
142 { KEY_TYPE, QStringLiteral("folder") },142//
143 { KEY_SUBTYPE, sandbox.path() },143//TEST_F(KeeperTemplateTest, BackupRun)
144 { KEY_HELPER, QString::fromUtf8(FAKE_BACKUP_HELPER_EXEC) }144//{
145 };145// QTemporaryDir sandbox;
146146//
147 // add it147// // build a backup choice
148 auto msg = mock_iface_->call(QStringLiteral("AddBackupChoice"), uuid, props);148// const auto uuid = QUuid::createUuid().toString();
149 EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());149// const QMap<QString,QVariant> props {
150150// { KEY_NAME, QStringLiteral("Music") },
151 // start the backup151// { KEY_TYPE, QStringLiteral("folder") },
152 QDBusReply<void> reply = user_iface_->call("StartBackup", QStringList{uuid});152// { KEY_SUBTYPE, sandbox.path() },
153 EXPECT_TRUE(reply.isValid()) << qPrintable(reply.error().message());153// { KEY_HELPER, QString::fromUtf8(FAKE_BACKUP_HELPER_EXEC) }
154 ASSERT_TRUE(wait_for_tasks_to_finish());154// };
155155//
156 // ask keeper for the blob156// // add it
157 QDBusReply<QByteArray> blob = mock_iface_->call(QStringLiteral("GetBackupData"), uuid);157// auto msg = mock_iface_->call(QStringLiteral("AddBackupChoice"), uuid, props);
158 EXPECT_TRUE(reply.isValid()) << qPrintable(reply.error().message());158// EXPECT_NE(QDBusMessage::ErrorMessage, msg.type()) << qPrintable(msg.errorMessage());
159159//
160 // check the results160// // start the backup
161 const auto expected_blob = QByteArray(FAKE_BACKUP_HELPER_PAYLOAD);161// QDBusReply<void> reply = user_iface_->call("StartBackup", QStringList{uuid});
162 ASSERT_EQ(expected_blob, blob);162// EXPECT_TRUE(reply.isValid()) << qPrintable(reply.error().message());
163}163// ASSERT_TRUE(wait_for_tasks_to_finish());
164//
165// // ask keeper for the blob
166// QDBusReply<QByteArray> blob = mock_iface_->call(QStringLiteral("GetBackupData"), uuid);
167// EXPECT_TRUE(reply.isValid()) << qPrintable(reply.error().message());
168//
169// // check the results
170// const auto expected_blob = QByteArray(FAKE_BACKUP_HELPER_PAYLOAD);
171// ASSERT_EQ(expected_blob, blob);
172//}
164173
=== modified file 'tests/integration/helpers/helpers-test-failure.cpp'
--- tests/integration/helpers/helpers-test-failure.cpp 2016-12-14 11:00:21 +0000
+++ tests/integration/helpers/helpers-test-failure.cpp 2016-12-22 14:35:27 +0000
@@ -48,7 +48,7 @@
48 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());48 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
4949
50 // ask for a list of backup choices50 // ask for a list of backup choices
51 QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");51 QDBusReply<keeper::KeeperItemsMap> choices = user_iface->call("GetBackupChoices");
52 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());52 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
5353
54 auto user_option = QStringLiteral("XDG_MUSIC_DIR");54 auto user_option = QStringLiteral("XDG_MUSIC_DIR");
@@ -90,26 +90,26 @@
90 // this one uses pooling so it should just call Get once90 // this one uses pooling so it should just call Get once
91 EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid}, "failed", user_iface));91 EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid}, "failed", user_iface));
9292
93 QVariant error_value;93 keeper::KeeperItem item_value;
94 EXPECT_TRUE(get_task_property_now(user_folder_uuid, user_iface, "error", error_value));94 EXPECT_TRUE(get_task_value_now(user_folder_uuid, user_iface, item_value));
95 bool conversion_ok;95 bool conversion_ok;
96 auto keeper_error = keeper::convertFromDBusVariant(error_value, &conversion_ok);96 auto keeper_error = item_value.get_error(&conversion_ok);
97 EXPECT_TRUE(conversion_ok);97 EXPECT_TRUE(conversion_ok);
98 EXPECT_EQ(keeper_error, keeper::KeeperError::HELPER_WRITE_ERROR);98 EXPECT_EQ(keeper::Error::HELPER_WRITE, keeper_error);
9999
100 // check that the content of the file is the expected100 // check that the content of the file is the expected
101 EXPECT_EQ(0, StorageFrameworkLocalUtils::check_storage_framework_nb_files());101 EXPECT_EQ(0, StorageFrameworkLocalUtils::check_storage_framework_nb_files());
102102
103 // check that the state is failed103 // check that the state is failed
104 QVariantDictMap state = user_iface->state();104 auto state = user_iface->state();
105105
106 // check that the state has the uuid106 // check that the state has the uuid
107 QVariantDictMap::const_iterator iter = state.find(user_folder_uuid);107 auto iter = state.find(user_folder_uuid);
108 EXPECT_TRUE(iter != state.end());108 EXPECT_TRUE(iter != state.end());
109 auto state_values = state[user_folder_uuid];109 auto state_values = state[user_folder_uuid];
110110
111 EXPECT_EQ(std::string{"failed"}, state_values["action"].toString().toStdString());111 EXPECT_EQ("failed", state_values.get_status());
112 EXPECT_EQ(std::string{"Music"}, state_values["display-name"].toString().toStdString());112 EXPECT_EQ("Music", state_values.get_display_name());
113 // sent 1 byte more than the expected, so percentage has to be greater than 1.0113 // sent 1 byte more than the expected, so percentage has to be greater than 1.0
114 EXPECT_GT(state_values["percent-done"].toFloat(), 1.0);114 EXPECT_LT(1.0, state_values.get_percent_done());
115}115}
116116
=== modified file 'tests/integration/helpers/helpers-test.cc'
--- tests/integration/helpers/helpers-test.cc 2016-12-21 08:36:57 +0000
+++ tests/integration/helpers/helpers-test.cc 2016-12-22 14:35:27 +0000
@@ -76,7 +76,7 @@
76 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());76 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
7777
78 // ask for a list of backup choices78 // ask for a list of backup choices
79 QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");79 QDBusReply<keeper::KeeperItemsMap> choices = user_iface->call("GetBackupChoices");
80 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());80 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
8181
82 QString user_option = QStringLiteral("XDG_MUSIC_DIR");82 QString user_option = QStringLiteral("XDG_MUSIC_DIR");
@@ -145,7 +145,7 @@
145 // finally check that we have a valid manifest file.145 // finally check that we have a valid manifest file.
146 EXPECT_TRUE(check_manifest_file(backup_items));146 EXPECT_TRUE(check_manifest_file(backup_items));
147147
148 QDBusPendingReply<QVariantDictMap> restore_choices_reply = user_iface->call("GetRestoreChoices");148 QDBusPendingReply<keeper::KeeperItemsMap> restore_choices_reply = user_iface->call("GetRestoreChoices");
149 restore_choices_reply.waitForFinished();149 restore_choices_reply.waitForFinished();
150 EXPECT_TRUE(restore_choices_reply.isValid()) << qPrintable(choices.error().message());150 EXPECT_TRUE(restore_choices_reply.isValid()) << qPrintable(choices.error().message());
151151
@@ -195,7 +195,7 @@
195 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());195 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
196196
197 // ask for a list of backup choices197 // ask for a list of backup choices
198 QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");198 QDBusReply<keeper::KeeperItemsMap> choices = user_iface->call("GetBackupChoices");
199 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());199 EXPECT_TRUE(choices.isValid()) << qPrintable(choices.error().message());
200200
201 QString user_option = QStringLiteral("XDG_MUSIC_DIR");201 QString user_option = QStringLiteral("XDG_MUSIC_DIR");
@@ -316,7 +316,7 @@
316316
317 ASSERT_EQ(1, spy_error.count());317 ASSERT_EQ(1, spy_error.count());
318 arguments = spy_error.takeFirst();318 arguments = spy_error.takeFirst();
319 EXPECT_EQ(keeper::KeeperError::HELPER_START_TIMEOUT, qvariant_cast<keeper::KeeperError>(arguments.at(0)));319 EXPECT_EQ(keeper::Error::HELPER_START_TIMEOUT, qvariant_cast<keeper::Error>(arguments.at(0)));
320}320}
321321
322TEST_F(TestHelpers, Inactivity)322TEST_F(TestHelpers, Inactivity)
@@ -346,5 +346,5 @@
346346
347 ASSERT_EQ(1, spy_error.count());347 ASSERT_EQ(1, spy_error.count());
348 arguments = spy_error.takeFirst();348 arguments = spy_error.takeFirst();
349 EXPECT_EQ(keeper::KeeperError::HELPER_INACTIVITY_DETECTED, qvariant_cast<keeper::KeeperError>(arguments.at(0)));349 EXPECT_EQ(keeper::Error::HELPER_INACTIVITY_DETECTED, qvariant_cast<keeper::Error>(arguments.at(0)));
350}350}
351351
=== modified file 'tests/integration/helpers/restore-test.cpp'
--- tests/integration/helpers/restore-test.cpp 2016-10-28 15:11:21 +0000
+++ tests/integration/helpers/restore-test.cpp 2016-12-22 14:35:27 +0000
@@ -92,7 +92,7 @@
92 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());92 ASSERT_TRUE(user_iface->isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
9393
94 // ask for a list of backup choices94 // ask for a list of backup choices
95 QDBusPendingReply<QVariantDictMap> choices_reply = user_iface->call("GetRestoreChoices");95 QDBusPendingReply<keeper::KeeperItemsMap> choices_reply = user_iface->call("GetRestoreChoices");
96 choices_reply.waitForFinished();96 choices_reply.waitForFinished();
97 EXPECT_TRUE(choices_reply.isFinished());97 EXPECT_TRUE(choices_reply.isFinished());
98 EXPECT_TRUE(choices_reply.isValid()) << qPrintable(choices_reply.error().message());98 EXPECT_TRUE(choices_reply.isValid()) << qPrintable(choices_reply.error().message());
9999
=== modified file 'tests/integration/helpers/test-helpers-base.cpp'
--- tests/integration/helpers/test-helpers-base.cpp 2016-12-21 08:36:57 +0000
+++ tests/integration/helpers/test-helpers-base.cpp 2016-12-22 14:35:27 +0000
@@ -35,6 +35,7 @@
3535
36bool qvariant_to_map(QVariant const& variant, QVariantMap& map)36bool qvariant_to_map(QVariant const& variant, QVariantMap& map)
37{37{
38 qDebug() << "VARIANT TYPE FOR STATE: " << variant.typeName();
38 if (variant.type() == QMetaType::QVariantMap)39 if (variant.type() == QMetaType::QVariantMap)
39 {40 {
40 map = variant.toMap();41 map = variant.toMap();
@@ -45,11 +46,13 @@
45 return false;46 return false;
46}47}
4748
48bool qdbus_argument_to_variant_dict_map(QVariant const& variant, QVariantDictMap& map)49bool qdbus_argument_to_keeper_items_map(QVariant const& variant, keeper::KeeperItemsMap& map)
49{50{
51 qDebug() << "**** VARIANT TYPE FOR STATE: " << variant.typeName();
50 if (variant.canConvert<QDBusArgument>())52 if (variant.canConvert<QDBusArgument>())
51 {53 {
52 QDBusArgument value(variant.value<QDBusArgument>());54 QDBusArgument value(variant.value<QDBusArgument>());
55 qDebug() << "VALUE CURRENT TYPE: " << value.currentType() << " SIGNATURE: " << value.currentSignature();
53 if (value.currentType() == QDBusArgument::MapType)56 if (value.currentType() == QDBusArgument::MapType)
54 {57 {
55 value >> map;58 value >> map;
@@ -57,7 +60,7 @@
57 }60 }
58 else61 else
59 {62 {
60 qWarning() << Q_FUNC_INFO << ": Could not convert variant to QVariantDictMap. Variant received has type " << value.currentType();63 qWarning() << Q_FUNC_INFO << ": Could not convert variant to keeper::KeeperItemsMap. Variant received has type " << value.currentType();
61 }64 }
62 }65 }
63 else66 else
@@ -67,7 +70,7 @@
67 return false;70 return false;
68}71}
6972
70bool get_property_qvariant_dict_map(QString const & property, QVariant const &variant, QVariantDictMap & map)73bool get_property_qvariant_keeper_items_map(QString const & property, QVariant const &variant, keeper::KeeperItemsMap & map)
71{74{
72 QVariantMap properties_map;75 QVariantMap properties_map;
73 if (!qvariant_to_map(variant, properties_map))76 if (!qvariant_to_map(variant, properties_map))
@@ -83,7 +86,7 @@
83 return false;86 return false;
84 }87 }
8588
86 if(!qdbus_argument_to_variant_dict_map((*iter), map))89 if(!qdbus_argument_to_keeper_items_map((*iter), map))
87 {90 {
88 qWarning() << Q_FUNC_INFO << ": Error converting property [" << property << "] to QVariantDictMap";91 qWarning() << Q_FUNC_INFO << ": Error converting property [" << property << "] to QVariantDictMap";
89 return false;92 return false;
@@ -441,7 +444,7 @@
441 return finished;444 return finished;
442}445}
443446
444bool TestHelpersBase::get_task_property_now(QString const & uuid, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, QString const & property, QVariant & value) const447bool TestHelpersBase::get_task_value_now(QString const & uuid, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, keeper::KeeperItem & value) const
445{448{
446 auto state = keeper_user_iface->state();449 auto state = keeper_user_iface->state();
447 auto iter = state.find(uuid);450 auto iter = state.find(uuid);
@@ -450,29 +453,23 @@
450 qWarning() << "Task " << uuid << " was not found in State";453 qWarning() << "Task " << uuid << " was not found in State";
451 return false;454 return false;
452 }455 }
453456 value = (*iter);
454 auto iter_props = (*iter).find(property);457
455 if (iter_props == (*iter).end())
456 {
457 qWarning() << "Property " << property << " was not found for task " << uuid;
458 return false;
459 }
460
461 value = (*iter_props);
462 return true;458 return true;
463}459}
464460
465bool TestHelpersBase::check_task_has_action_state(QVariantDictMap const & state, QString const & uuid, QString const & action_state)461bool TestHelpersBase::check_task_has_action_state(keeper::KeeperItemsMap const & state, QString const & uuid, QString const & action_state)
466{462{
467 auto iter = state.find(uuid);463 auto iter = state.find(uuid);
468 if (iter == state.end())464 if (iter == state.end())
469 return false;465 return false;
470466
471 auto iter_props = (*iter).find("action");467 bool valid_status;
472 if (iter_props == (*iter).end())468 auto status = (*iter).get_status(&valid_status);
469 if (!valid_status)
473 return false;470 return false;
474471
475 return (*iter_props).toString() == action_state;472 return status == action_state;
476}473}
477474
478bool TestHelpersBase::capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec)475bool TestHelpersBase::capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec)
@@ -510,8 +507,8 @@
510 {507 {
511 return false;508 return false;
512 }509 }
513 QVariantDictMap keeper_state;510 keeper::KeeperItemsMap keeper_state;
514 if (!get_property_qvariant_dict_map("State", arguments.at(1), keeper_state))511 if (!get_property_qvariant_keeper_items_map("State", arguments.at(1), keeper_state))
515 {512 {
516 return false;513 return false;
517 }514 }
@@ -595,8 +592,8 @@
595 {592 {
596 return false;593 return false;
597 }594 }
598 QVariantDictMap keeper_state;595 keeper::KeeperItemsMap keeper_state;
599 if (!get_property_qvariant_dict_map("State", arguments.at(1), keeper_state))596 if (!get_property_qvariant_keeper_items_map("State", arguments.at(1), keeper_state))
600 {597 {
601 return false;598 return false;
602 }599 }
@@ -655,7 +652,7 @@
655 return false;652 return false;
656}653}
657654
658QString TestHelpersBase::get_uuid_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const655QString TestHelpersBase::get_uuid_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const
659{656{
660 for(auto iter = choices.begin(); iter != choices.end(); ++iter)657 for(auto iter = choices.begin(); iter != choices.end(); ++iter)
661 {658 {
@@ -674,7 +671,7 @@
674 return QString();671 return QString();
675}672}
676673
677QString TestHelpersBase::get_type_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const674QString TestHelpersBase::get_type_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const
678{675{
679 for(auto iter = choices.begin(); iter != choices.end(); ++iter)676 for(auto iter = choices.begin(); iter != choices.end(); ++iter)
680 {677 {
@@ -698,7 +695,7 @@
698 return QString();695 return QString();
699}696}
700697
701QString TestHelpersBase::get_display_name_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const698QString TestHelpersBase::get_display_name_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const
702{699{
703 for(auto iter = choices.begin(); iter != choices.end(); ++iter)700 for(auto iter = choices.begin(); iter != choices.end(); ++iter)
704 {701 {
705702
=== modified file 'tests/integration/helpers/test-helpers-base.h'
--- tests/integration/helpers/test-helpers-base.h 2016-12-21 08:36:57 +0000
+++ tests/integration/helpers/test-helpers-base.h 2016-12-22 14:35:27 +0000
@@ -95,17 +95,17 @@
9595
96 bool wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout_msec = 15000);96 bool wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout_msec = 15000);
9797
98 bool check_task_has_action_state(QVariantDictMap const & state, QString const & uuid, QString const & action_state);98 bool check_task_has_action_state(keeper::KeeperItemsMap const & state, QString const & uuid, QString const & action_state);
9999
100 bool get_task_property_now(QString const & uuid, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, QString const & property, QVariant & value) const;100 bool get_task_value_now(QString const & uuid, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, keeper::KeeperItem & value) const;
101101
102 bool capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec = 15000);102 bool capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec = 15000);
103103
104 bool cancel_first_task_at_percentage(QSignalSpy & spy, double expected_percentage, QSharedPointer<DBusInterfaceKeeperUser> const & user_iface, int max_timeout_msec = 15000);104 bool cancel_first_task_at_percentage(QSignalSpy & spy, double expected_percentage, QSharedPointer<DBusInterfaceKeeperUser> const & user_iface, int max_timeout_msec = 15000);
105105
106 QString get_uuid_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const;106 QString get_uuid_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const;
107 QString get_type_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const;107 QString get_type_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const;
108 QString get_display_name_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const;108 QString get_display_name_for_xdg_folder_path(QString const &path, keeper::KeeperItemsMap const & choices) const;
109109
110 bool check_manifest_file(QVector<BackupItem> const & backup_items);110 bool check_manifest_file(QVector<BackupItem> const & backup_items);
111111

Subscribers

People subscribed via source and target branches

to all changes: