Merge lp:~unity-api-team/storage-framework/merge-devel into lp:storage-framework

[Michi Henning]

Merged devel at revision 64. Lots of fixes in preparation for integration with backup service and mcloud provider.

Merged devel at revision 64. Lots of fixes in preparation for integration with backup service and mcloud provider.

[Michi Henning (michihenning)]

Looks good, thanks!

review: Approve

[Michi Henning (michihenning)]

Oops, sorry, that wasn't meant to be approved.

[lp:~unity-api-team/storage-framework/merge-devel]

57. By Michi Henning on 2016-08-23

Increased remote client coverage.

Approved by James Henstridge, unity-api-1-bot.

58. By Michi Henning on 2016-08-24

Added provider headers to unit tests.

Approved by unity-api-1-bot, James Henstridge.

59. By Michi Henning on 2016-08-24

Removed half-close on the provider side because this messes with QLocalSocket on the client side.

Approved by James Henstridge, unity-api-1-bot.

60. By Michi Henning on 2016-08-25

Increased test timeouts because CI builders are hopelessly overloaded.

Approved by unity-api-1-bot, James Henstridge.

61. By James Henstridge on 2016-08-25

Add a drain() method to UploadJob to allow the provider to read the last bit of data from the socket when the client asks to finish the upload.

Approved by unity-api-1-bot, Michi Henning.

62. By Michi Henning on 2016-08-25

Don't throw when unknown metadata key is received and log a warning instead.

Approved by unity-api-1-bot, Michi Henning, James Henstridge.

63. By Michi Henning on 2016-08-25

Removed stale debug trace. Suppressed more compile warnings from system headers that caused a lot of noise in the arm builds.

Approved by James Henstridge, unity-api-1-bot.

64. By Michi Henning on 2016-08-26

Merged devel at revision 64.

65. By Michi Henning on 2016-09-09

Merged devel at revision 68.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-07-22 08:38:24 +0000
+++ CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -17,7 +17,7 @@
 # These two should be incremented when the ABI changes.
 set(SF_CLIENT_SOVERSION "0")
 execute_process(
-  COMMAND /bin/sh ${CMAKE_CURRENT_SOURCE_DIR}/get-provider-soversion.sh
+  COMMAND /bin/sh ${CMAKE_CURRENT_SOURCE_DIR}/tools/get-provider-soversion.sh
   OUTPUT_VARIABLE SF_PROVIDER_SOVERSION
   OUTPUT_STRIP_TRAILING_WHITESPACE
   RESULT_VARIABLE result)
@@ -108,7 +108,7 @@
 
 include(GNUInstallDirs)
 
-find_package(Boost COMPONENTS filesystem system thread REQUIRED)
+find_package(Boost 1.56 COMPONENTS filesystem system thread REQUIRED)
 find_package(Qt5Concurrent REQUIRED)
 find_package(Qt5Core REQUIRED)
 find_package(Qt5DBus REQUIRED)
@@ -130,8 +130,11 @@
 enable_coverage_report(
     TARGETS
         qt-client-lib-common
+        storage-framework-common-internal
         storage-framework-qt-client
         storage-framework-qt-local-client
+        sf-provider-objects
+        storage-framework-provider
     FILTER
         ${CMAKE_SOURCE_DIR}/tests/*
         ${CMAKE_BINARY_DIR}/*
 
=== modified file 'data/provider.xml'
--- data/provider.xml	2016-07-11 07:17:04 +0000
+++ data/provider.xml	2016-09-09 02:13:43 +0000
@@ -5,14 +5,17 @@
       com.canonical.StorageFramework.Provider:
       @short_description: Interface providing access to a storage account
 
-      For methods dealing with metadata, the representation
-      "(ssssia{sv})" is used, where the struct members are:
+      For methods returning metadata, the representation
+      "(sasssia{sv})" is used, where the struct members are:
         - item_id
-        - parent_id
+        - parent_ids
         - name
         - etag
         - type (enum: file, folder, root)
         - metadata
+
+      Note that parent_ids is a sequence of IDs instead of a single ID to allow the client to
+      navigate items in Google Drive, which permits more than one parent for a file or folder.
   -->
   <interface name="com.canonical.StorageFramework.Provider">
     <!--
@@ -25,7 +28,7 @@
         of files, this list will contain a single item.
     -->
     <method name="Roots">
-      <arg type="a(ssssia{sv})" name="roots" direction="out"/>
+      <arg type="a(sasssia{sv})" name="roots" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList&lt;unity::storage::internal::ItemMetadata&gt;"/>
     </method>
 
@@ -45,7 +48,7 @@
     <method name="List">
       <arg type="s" name="item_id" direction="in"/>
       <arg type="s" name="page_token" direction="in"/>
-      <arg type="a(ssssia{sv})" name="children" direction="out"/>
+      <arg type="a(sasssia{sv})" name="children" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList&lt;unity::storage::internal::ItemMetadata&gt;"/>
       <arg type="s" name="next_token" direction="out"/>
     </method>
@@ -60,7 +63,7 @@
     <method name="Lookup">
       <arg type="s" name="parent_id" direction="in"/>
       <arg type="s" name="name" direction="in"/>
-      <arg type="a(ssssia{sv})" name="items" direction="out"/>
+      <arg type="a(sasssia{sv})" name="items" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList&lt;unity::storage::internal::ItemMetadata&gt;"/>
     </method>
 
@@ -72,7 +75,7 @@
     -->
     <method name="Metadata">
       <arg type="s" name="item_id" direction="in"/>
-      <arg type="(ssssia{sv})" name="metadata" direction="out"/>
+      <arg type="(sasssia{sv})" name="metadata" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="unity::storage::internal::ItemMetadata"/>
     </method>
 
@@ -86,7 +89,7 @@
     <method name="CreateFolder">
       <arg type="s" name="parent_id" direction="in"/>
       <arg type="s" name="name" direction="in"/>
-      <arg type="(ssssia{sv})" name="metadata" direction="out"/>
+      <arg type="(sasssia{sv})" name="metadata" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="unity::storage::internal::ItemMetadata"/>
     </method>
 
@@ -160,7 +163,7 @@
     -->
     <method name="FinishUpload">
       <arg type="s" name="upload_id" direction="in"/>
-      <arg type="(ssssia{sv})" name="metadata" direction="out"/>
+      <arg type="(sasssia{sv})" name="metadata" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="unity::storage::internal::ItemMetadata"/>
     </method>
 
 
=== modified file 'debian/bileto_pre_release_hook'
--- debian/bileto_pre_release_hook	2016-07-22 04:23:08 +0000
+++ debian/bileto_pre_release_hook	2016-09-09 02:13:43 +0000
@@ -2,7 +2,7 @@
 
 set -eu
 
-soversion=$(sh ./get-provider-soversion.sh)
+soversion=$(sh ./tools/get-provider-soversion.sh)
 
 infile=./debian/control.in
 outfile=./debian/control
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-08-04 07:20:09 +0000
+++ debian/changelog	2016-09-09 02:13:43 +0000
@@ -1,3 +1,9 @@
+storage-framework (0.1+16.10.20160804.1-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Merged devel at revision 64.
+
+ -- Michi Henning <[e-mail]>  Fri, 26 Aug 2016 14:03:02 +1000
+
 storage-framework (0.1+16.10.20160804.1-0ubuntu1) yakkety; urgency=medium
 
   [ Michi Henning ]
 
=== modified file 'demo/provider_test/CMakeLists.txt'
--- demo/provider_test/CMakeLists.txt	2016-05-23 02:27:16 +0000
+++ demo/provider_test/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -1,4 +1,3 @@
-
 add_definitions(-DBOOST_THREAD_VERSION=4)
 
 add_executable(provider-test provider-test.cpp)
 
=== modified file 'demo/provider_test/provider-test.cpp'
--- demo/provider_test/provider-test.cpp	2016-07-26 03:30:05 +0000
+++ demo/provider_test/provider-test.cpp	2016-09-09 02:13:43 +0000
@@ -17,6 +17,8 @@
  */
 
 #include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/Exceptions.h>
+#include <unity/storage/provider/metadata_keys.h>
 #include <unity/storage/provider/ProviderBase.h>
 #include <unity/storage/provider/Server.h>
 #include <unity/storage/provider/TempfileUploadJob.h>
@@ -32,47 +34,8 @@
 using namespace unity::storage::provider;
 using namespace std;
 
-#if BOOST_VERSION >= 105600
 using boost::make_ready_future;
 using boost::make_exceptional_future;
-#else
-namespace
-{
-
-boost::future<void> make_ready_future()
-{
-    boost::promise<void> p;
-    p.set_value();
-    return p.get_future();
-}
-
-template <typename T>
-boost::future<T> make_ready_future(T& value)
-{
-    boost::promise<T> p;
-    p.set_value(value);
-    return p.get_future();
-}
-
-template <typename T>
-boost::future<T> make_ready_future(T&& value)
-{
-    boost::promise<T> p;
-    p.set_value(std::move(value));
-    return p.get_future();
-}
-
-template <typename T, typename E>
-boost::future<T> make_exceptional_future(E const& ex)
-{
-    boost::promise<T> p;
-    p.set_exception(boost::copy_exception(ex));
-    return p.get_future();
-}
-
-}
-#endif
-
 
 class MyProvider : public ProviderBase
 {
@@ -140,7 +103,7 @@
     printf("roots() called by %s (%d)\n", ctx.security_label.c_str(), ctx.pid);
     fflush(stdout);
     ItemList roots = {
-        {"root_id", "", "Root", "etag", ItemType::root, {}},
+        {"root_id", {}, "Root", "etag", ItemType::root, {}},
     };
     return make_ready_future<ItemList>(roots);
 }
@@ -153,14 +116,20 @@
     fflush(stdout);
     if (item_id != "root_id")
     {
-        return make_exceptional_future<tuple<ItemList,string>>(runtime_error("unknown folder"));
+        string msg = string("Item::list(): no such item: \"") + item_id + "\"";
+        return make_exceptional_future<tuple<ItemList,string>>(NotExistsException(msg, item_id));
     }
     if (page_token != "")
     {
-        return make_exceptional_future<tuple<ItemList,string>>(runtime_error("unknown page token"));
+        string msg = string("Item::list(): invalid page token: \"") + page_token + "\"";
+        return make_exceptional_future<tuple<ItemList,string>>(LogicException(msg));
     }
-    ItemList children = {
-        {"child_id", "root_id", "Child", "etag", ItemType::file, {}}
+    ItemList children =
+    {
+        {
+            "child_id", { "root_id" }, "Child", "etag", ItemType::file,
+            { { SIZE_IN_BYTES, 0 }, { LAST_MODIFIED_TIME, "2007-04-05T14:30Z" } }
+        }
     };
     boost::promise<tuple<ItemList,string>> p;
     p.set_value(make_tuple(children, string()));
@@ -172,12 +141,20 @@
 {
     printf("lookup('%s', '%s') called by %s (%d)\n", parent_id.c_str(), name.c_str(), ctx.security_label.c_str(), ctx.pid);
     fflush(stdout);
-    if (parent_id != "root_id" || name != "Child")
-    {
-        return make_exceptional_future<ItemList>(runtime_error("file not found"));
-    }
-    ItemList children = {
-        {"child_id", "root_id", "Child", "etag", ItemType::file, {}}
+    if (parent_id != "root_id")
+    {
+        string msg = string("Folder::lookup(): no such item: \"") + parent_id + "\"";
+        return make_exceptional_future<ItemList>(NotExistsException(msg, parent_id));
+    }
+    if (name != "Child")
+    {
+        string msg = string("Folder::lookup(): no such item: \"") + name + "\"";
+        return make_exceptional_future<ItemList>(NotExistsException(msg, name));
+    }
+    ItemList children =
+    {
+        { "child_id", { "root_id" }, "Child", "etag", ItemType::file,
+          { { SIZE_IN_BYTES, 0 }, { LAST_MODIFIED_TIME, "2007-04-05T14:30Z" } } }
     };
     return make_ready_future<ItemList>(children);
 }
@@ -189,15 +166,24 @@
     fflush(stdout);
     if (item_id == "root_id")
     {
-        Item metadata{"root_id", "", "Root", "etag", ItemType::root, {}};
+        Item metadata{"root_id", {}, "Root", "etag", ItemType::root, {}};
         return make_ready_future<Item>(metadata);
     }
     else if (item_id == "child_id")
     {
-        Item metadata{"child_id", "root_id", "Child", "etag", ItemType::file, {}};
-        return make_ready_future<Item>(metadata);
-    }
-    return make_exceptional_future<Item>(runtime_error("no such file"));
+        Item metadata
+        {
+            "child_id", { "root_id" }, "Child", "etag", ItemType::file,
+            { { SIZE_IN_BYTES, 0 }, { LAST_MODIFIED_TIME, "2007-04-05T14:30Z" } }
+        };
+        return make_ready_future<Item>(metadata);
+    }
+    else if (item_id == "child_folder_id")
+    {
+        Item metadata{"child_folder_id", { "root_id" }, "Child_Folder", "etag", ItemType::folder, {}};
+        return make_ready_future<Item>(metadata);
+    }
+    return make_exceptional_future<Item>(NotExistsException("metadata(): no such item: " + item_id, item_id));
 }
 
 boost::future<Item> MyProvider::create_folder(
@@ -206,7 +192,7 @@
 {
     printf("create_folder('%s', '%s') called by %s (%d)\n", parent_id.c_str(), name.c_str(), ctx.security_label.c_str(), ctx.pid);
     fflush(stdout);
-    Item metadata{"new_folder_id", parent_id, name, "etag", ItemType::folder, {}};
+    Item metadata{"new_folder_id", { parent_id }, name, "etag", ItemType::folder, {}};
     return make_ready_future<Item>(metadata);
 }
 
@@ -242,7 +228,12 @@
 
     unique_ptr<DownloadJob> job(new MyDownloadJob(make_job_id()));
     const char contents[] = "Hello world";
-    write(job->write_socket(), contents, sizeof(contents));
+    if (write(job->write_socket(), contents, sizeof(contents)) != sizeof(contents))
+    {
+        ResourceException e("download(): write failed", errno);
+        job->report_error(make_exception_ptr(e));
+        return make_exceptional_future<unique_ptr<DownloadJob>>(e);
+    }
     job->report_complete();
     return make_ready_future(std::move(job));
 }
@@ -261,7 +252,7 @@
 {
     printf("move('%s', '%s', '%s') called by %s (%d)\n", item_id.c_str(), new_parent_id.c_str(), new_name.c_str(), ctx.security_label.c_str(), ctx.pid);
     fflush(stdout);
-    Item metadata{item_id, new_parent_id, new_name, "etag", ItemType::file, {}};
+    Item metadata{item_id, { new_parent_id }, new_name, "etag", ItemType::file, {}};
     return make_ready_future(metadata);
 }
 
@@ -271,7 +262,7 @@
 {
     printf("copy('%s', '%s', '%s') called by %s (%d)\n", item_id.c_str(), new_parent_id.c_str(), new_name.c_str(), ctx.security_label.c_str(), ctx.pid);
     fflush(stdout);
-    Item metadata{"new_item_id", new_parent_id, new_name, "etag", ItemType::file, {}};
+    Item metadata{"new_item_id", { new_parent_id }, new_name, "etag", ItemType::file, {}};
     return make_ready_future(metadata);
 }
 
@@ -294,7 +285,11 @@
     unlink(new_filename.c_str());
     link(old_filename.c_str(), new_filename.c_str());
 
-    Item metadata{"some_id", "", "some_upload", "etag", ItemType::file, {}};
+    Item metadata
+    {
+        "some_id", { "root_id" }, "some_upload", "etag", ItemType::file,
+        { { SIZE_IN_BYTES, 10 }, { LAST_MODIFIED_TIME, "2011-04-05T14:30:10.005Z" } }
+    };
     return make_ready_future(metadata);
 }
 
 
=== modified file 'include/unity/storage/internal/ItemMetadata.h'
--- include/unity/storage/internal/ItemMetadata.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/internal/ItemMetadata.h	2016-09-09 02:13:43 +0000
@@ -21,9 +21,12 @@
 #include <unity/storage/common.h>
 
 #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <QMap>
 #include <QVariant>
+#include <QVector>
 #pragma GCC diagnostic pop
 
 namespace unity
@@ -36,7 +39,7 @@
 struct ItemMetadata
 {
     QString item_id;
-    QString parent_id;
+    QVector<QString> parent_ids;
     QString name;
     QString etag;
     ItemType type;
 
=== added file 'include/unity/storage/internal/TraceMessageHandler.h'
--- include/unity/storage/internal/TraceMessageHandler.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/internal/TraceMessageHandler.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#include <QDebug>
+#pragma GCC diagnostic pop
+
+namespace unity
+{
+namespace storage
+{
+namespace internal
+{
+
+class TraceMessageHandler final
+{
+public:
+    TraceMessageHandler(std::string const& prog_name);
+    ~TraceMessageHandler();
+
+private:
+    QtMessageHandler old_message_handler_;
+};
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace unity
 
=== added file 'include/unity/storage/internal/dbus_error.h'
--- include/unity/storage/internal/dbus_error.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/internal/dbus_error.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+namespace unity
+{
+namespace storage
+{
+namespace internal
+{
+
+constexpr char DBUS_ERROR_PREFIX[] = "com.canonical.StorageFramework.";
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace unity
 
=== added file 'include/unity/storage/internal/dbusmarshal.h'
--- include/unity/storage/internal/dbusmarshal.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/internal/dbusmarshal.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/internal/ItemMetadata.h>
+
+#include <QDBusArgument>
+#include <QMetaType>
+
+namespace unity
+{
+namespace storage
+{
+namespace internal
+{
+
+QDBusArgument& operator<<(QDBusArgument& argument, ItemMetadata const& metadata);
+QDBusArgument const& operator>>(QDBusArgument const& argument, ItemMetadata& metadata);
+
+QDBusArgument& operator<<(QDBusArgument& argument, QList<ItemMetadata> const& md_list);
+QDBusArgument const& operator>>(QDBusArgument const& argument, QList<ItemMetadata>& md_list);
+
+}  // namespace internal
+}  // storage
+}  // unity
+
+Q_DECLARE_METATYPE(unity::storage::internal::ItemMetadata)
+Q_DECLARE_METATYPE(QList<unity::storage::internal::ItemMetadata>)
 
=== modified file 'include/unity/storage/provider/CMakeLists.txt'
--- include/unity/storage/provider/CMakeLists.txt	2016-07-11 03:28:40 +0000
+++ include/unity/storage/provider/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -3,3 +3,5 @@
 
 install(FILES ${provider_headers}
   DESTINATION ${provider_base_includedir}/${includeprefix})
+
+add_subdirectory(testing)
 
=== added file 'include/unity/storage/provider/Exceptions.h'
--- include/unity/storage/provider/Exceptions.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/Exceptions.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/visibility.h>
+
+#include <string>
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+
+// Note: Adding new exception types also requires updating the marshaling and
+//       unmarshaling code for exceptions in the client and server APIs.
+
+/**
+\brief Base exception class for all server-side exceptions.
+*/
+class UNITY_STORAGE_EXPORT StorageException : public std::exception
+{
+public:
+    StorageException(std::string const& exception_type, std::string const& error_message);
+    ~StorageException();
+
+    virtual char const* what() const noexcept override;
+
+    std::string type() const;
+    std::string error_message() const;
+
+private:
+    std::string what_string_;
+    std::string type_;
+    std::string error_message_;
+};
+
+/**
+\brief Indicates errors in the communication between the storage provider and the cloud service.
+*/
+class UNITY_STORAGE_EXPORT RemoteCommsException : public StorageException
+{
+public:
+    RemoteCommsException(std::string const& error_message);
+    ~RemoteCommsException();
+};
+
+/**
+\brief Indicates that an item does not exist or could not be found.
+*/
+class UNITY_STORAGE_EXPORT NotExistsException : public StorageException
+{
+public:
+    NotExistsException(std::string const& error_message, std::string const& key);
+    ~NotExistsException();
+
+    std::string key() const;
+
+private:
+    std::string key_;
+};
+
+/**
+\brief Indicates that an item cannot be created because it exists already.
+*/
+class UNITY_STORAGE_EXPORT ExistsException : public StorageException
+{
+public:
+    ExistsException(std::string const& error_message, std::string const& identity, std::string const& name);
+    ~ExistsException();
+
+    std::string native_identity() const;
+    std::string name() const;
+
+private:
+    std::string identity_;
+    std::string name_;
+};
+
+/**
+\brief Indicates that an upload detected a version mismatch.
+*/
+class UNITY_STORAGE_EXPORT ConflictException : public StorageException
+{
+public:
+    ConflictException(std::string const& error_message);
+    ~ConflictException();
+};
+
+/**
+\brief Indicates that an operation failed because of a permission problem.
+*/
+class UNITY_STORAGE_EXPORT PermissionException : public StorageException
+{
+public:
+    PermissionException(std::string const& error_message);
+    ~PermissionException();
+};
+
+/**
+\brief Indicates that an update failed because the provider ran out of space.
+*/
+class UNITY_STORAGE_EXPORT QuotaException : public StorageException
+{
+public:
+    QuotaException(std::string const& error_message);
+    ~QuotaException();
+};
+
+/**
+\brief Indicates that an upload or download was cancelled before it could complete.
+*/
+class UNITY_STORAGE_EXPORT CancelledException : public StorageException
+{
+public:
+    CancelledException(std::string const& error_message);
+    ~CancelledException();
+};
+
+/**
+\brief Indicates incorrect use of the API, such as calling methods in the wrong order.
+*/
+class UNITY_STORAGE_EXPORT LogicException : public StorageException
+{
+public:
+    LogicException(std::string const& error_message);
+    ~LogicException();
+};
+
+/**
+\brief Indicates an invalid parameter, such as a negative value when a positive one was
+expected, or a string that does not parse correctly or is empty when it should be non-empty.
+*/
+class UNITY_STORAGE_EXPORT InvalidArgumentException : public StorageException
+{
+public:
+    InvalidArgumentException(std::string const& error_message);
+    ~InvalidArgumentException();
+};
+
+/**
+\brief Indicates a system error, such as failure to create a file or folder,
+or any other (usually non-recoverable) kind of error that should not arise during normal operation.
+*/
+class UNITY_STORAGE_EXPORT ResourceException : public StorageException
+{
+public:
+    ResourceException(std::string const& error_message, int error_code);
+    ~ResourceException();
+
+    int error_code() const noexcept;
+
+private:
+    int error_code_;
+};
+
+/**
+\brief Indicates that the server side caught an exception that does not derive from
+StorageException, such as a std::exception, or caught some other unknown type (such as `int`).
+*/
+class UNITY_STORAGE_EXPORT UnknownException : public StorageException
+{
+public:
+    UnknownException(std::string const& error_message);
+    ~UnknownException();
+};
+
+}  // namespace provider
+}  // namespace storage
+}  // namespace unity
 
=== modified file 'include/unity/storage/provider/ProviderBase.h'
--- include/unity/storage/provider/ProviderBase.h	2016-07-14 00:17:14 +0000
+++ include/unity/storage/provider/ProviderBase.h	2016-09-09 02:13:43 +0000
@@ -23,6 +23,7 @@
 #include <unity/storage/provider/Credentials.h>
 
 #include <boost/thread/future.hpp>
+#include <boost/variant.hpp>
 
 #include <sys/types.h>
 #include <string>
@@ -48,15 +49,18 @@
     Credentials credentials;
 };
 
+// Note: When growing the set of supported variant types, add new types
+// to the *end* of the list, and update the marshaling code in dbusmarshal.cpp.
+typedef boost::variant<std::string, int64_t> MetadataValue;
+
 struct UNITY_STORAGE_EXPORT Item
 {
     std::string item_id;
-    std::string parent_id;
+    std::vector<std::string> parent_ids;
     std::string name;
     std::string etag;
     unity::storage::ItemType type;
-    // Should be map<string,variant>
-    std::map<std::string,std::string> metadata;
+    std::map<std::string, MetadataValue> metadata;
 };
 
 typedef std::vector<Item> ItemList;
 
=== modified file 'include/unity/storage/provider/TempfileUploadJob.h'
--- include/unity/storage/provider/TempfileUploadJob.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/TempfileUploadJob.h	2016-09-09 02:13:43 +0000
@@ -44,6 +44,12 @@
 
     std::string file_name() const;
 
+    // This function should be called from your finish()
+    // implementation to read the remaining data from the socket.  If
+    // the client has not closed the socket as expected, LogicError
+    // will be thrown.
+    void drain();
+
 protected:
     TempfileUploadJob(internal::TempfileUploadJobImpl *p) UNITY_STORAGE_HIDDEN;
 };
 
=== modified file 'include/unity/storage/provider/internal/AccountData.h'
--- include/unity/storage/provider/internal/AccountData.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/AccountData.h	2016-09-09 02:13:43 +0000
@@ -20,10 +20,15 @@
 
 #include <unity/storage/provider/Credentials.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <OnlineAccounts/Account>
 #include <OnlineAccounts/PendingCallWatcher>
 #include <QObject>
 #include <QDBusConnection>
+#pragma GCC diagnostic pop
 
 #include <string>
 
 
=== modified file 'include/unity/storage/provider/internal/DBusPeerCache.h'
--- include/unity/storage/provider/internal/DBusPeerCache.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/DBusPeerCache.h	2016-09-09 02:13:43 +0000
@@ -20,8 +20,13 @@
 #pragma once
 
 #include <boost/thread/future.hpp>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <QDBusConnection>
 #include <QDBusPendingReply>
+#pragma GCC diagnostic pop
 #include <QString>
 
 #include <functional>
 
=== modified file 'include/unity/storage/provider/internal/DownloadJobImpl.h'
--- include/unity/storage/provider/internal/DownloadJobImpl.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/DownloadJobImpl.h	2016-09-09 02:13:43 +0000
@@ -48,9 +48,6 @@
     int write_socket() const;
     int take_read_socket();
 
-    std::string const& sender_bus_name() const;
-    void set_sender_bus_name(std::string const& bus_name);
-
     void report_complete();
     void report_error(std::exception_ptr p);
     boost::future<void> finish(DownloadJob& job);
@@ -63,7 +60,6 @@
     std::string const download_id_;
     int read_socket_ = -1;
     int write_socket_ = -1;
-    std::string sender_bus_name_;
 
     std::mutex completion_lock_;
     bool completed_ = false;
 
=== modified file 'include/unity/storage/provider/internal/Handler.h'
--- include/unity/storage/provider/internal/Handler.h	2016-07-19 07:08:50 +0000
+++ include/unity/storage/provider/internal/Handler.h	2016-09-09 02:13:43 +0000
@@ -63,6 +63,8 @@
     void finished();
 
 private:
+    void marshal_exception(std::exception_ptr ep);
+
     std::shared_ptr<AccountData> const account_;
     Callback const callback_;
     QDBusConnection const bus_;
 
=== modified file 'include/unity/storage/provider/internal/MainLoopExecutor.h'
--- include/unity/storage/provider/internal/MainLoopExecutor.h	2016-07-19 03:26:36 +0000
+++ include/unity/storage/provider/internal/MainLoopExecutor.h	2016-09-09 02:13:43 +0000
@@ -19,13 +19,7 @@
 #pragma once
 
 #include <boost/version.hpp>
-
-#if BOOST_VERSION >= 105600
-#  define SF_SUPPORTS_EXECUTORS
-#endif
-#ifdef SF_SUPPORTS_EXECUTORS
-#  include <boost/thread/executor.hpp>
-#endif
+#include <boost/thread/executor.hpp>
 #include <QObject>
 
 #include <functional>
@@ -39,8 +33,6 @@
 namespace internal
 {
 
-#ifdef SF_SUPPORTS_EXECUTORS
-
 /* Declare future continuations like so to execute within the event
  * loop if possible:
  *
@@ -72,12 +64,6 @@
     Q_DISABLE_COPY(MainLoopExecutor)
 };
 
-#else
-
-#define EXEC_IN_MAIN /*nothing*/
-
-#endif
-
 }
 }
 }
 
=== modified file 'include/unity/storage/provider/internal/PendingJobs.h'
--- include/unity/storage/provider/internal/PendingJobs.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/PendingJobs.h	2016-09-09 02:13:43 +0000
@@ -18,14 +18,21 @@
 
 #pragma once
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <QDBusConnection>
 #include <QDBusServiceWatcher>
 #include <QObject>
+#include <QString>
+#pragma GCC diagnostic pop
 
 #include <map>
 #include <memory>
 #include <mutex>
 #include <string>
+#include <utility>
 
 namespace unity
 {
@@ -49,27 +56,30 @@
     explicit PendingJobs(QDBusConnection const& bus, QObject *parent=nullptr);
     virtual ~PendingJobs();
 
-    void add_download(std::unique_ptr<DownloadJob> &&job);
-    std::shared_ptr<DownloadJob> get_download(std::string const& download_id);
-    std::shared_ptr<DownloadJob> remove_download(std::string const& download_id);
+    void add_download(QString const& client_bus_name, std::unique_ptr<DownloadJob> &&job);
+    std::shared_ptr<DownloadJob> remove_download(QString const& client_bus_name, std::string const& download_id);
 
-    void add_upload(std::unique_ptr<UploadJob> &&job);
-    std::shared_ptr<UploadJob> get_upload(std::string const& upload_id);
-    std::shared_ptr<UploadJob> remove_upload(std::string const& upload_id);
+    void add_upload(QString const& client_bus_name, std::unique_ptr<UploadJob> &&job);
+    std::shared_ptr<UploadJob> remove_upload(QString const& client_bus_name, std::string const& upload_id);
 
 private Q_SLOTS:
     void service_disconnected(QString const& service_name);
 
 private:
-    void watch_peer(std::string const& bus_name);
-    void unwatch_peer(std::string const& bus_name);
+    void watch_peer(QString const& bus_name);
+    void unwatch_peer(QString const& bus_name);
+
+    template <typename Job>
+    void cancel_job(std::shared_ptr<Job> const& job,
+                    std::string const& identifier);
 
     std::mutex lock_;
-    std::map<std::string,std::shared_ptr<UploadJob>> uploads_;
-    std::map<std::string,std::shared_ptr<DownloadJob>> downloads_;
+    // Key is client_bus_name and upload or download ID.
+    std::map<std::pair<QString,std::string>,std::shared_ptr<UploadJob>> uploads_;
+    std::map<std::pair<QString,std::string>,std::shared_ptr<DownloadJob>> downloads_;
 
     QDBusServiceWatcher watcher_;
-    std::map<std::string,int> services_;
+    std::map<QString,int> services_;
 
     Q_DISABLE_COPY(PendingJobs)
 };
 
=== modified file 'include/unity/storage/provider/internal/ProviderInterface.h'
--- include/unity/storage/provider/internal/ProviderInterface.h	2016-07-14 00:17:14 +0000
+++ include/unity/storage/provider/internal/ProviderInterface.h	2016-09-09 02:13:43 +0000
@@ -21,11 +21,16 @@
 #include <unity/storage/internal/ItemMetadata.h>
 #include <unity/storage/provider/internal/Handler.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <QObject>
 #include <QList>
 #include <QDBusConnection>
 #include <QDBusContext>
 #include <QDBusUnixFileDescriptor>
+#pragma GCC diagnostic pop
 
 #include <map>
 #include <memory>
 
=== modified file 'include/unity/storage/provider/internal/ServerImpl.h'
--- include/unity/storage/provider/internal/ServerImpl.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/ServerImpl.h	2016-09-09 02:13:43 +0000
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <unity/storage/provider/Server.h>
+#include <unity/storage/internal/TraceMessageHandler.h>
 #include <unity/storage/provider/internal/DBusPeerCache.h>
 #include <unity/storage/provider/internal/ProviderInterface.h>
 
@@ -58,6 +59,7 @@
     ServerBase* const server_;
     std::string const bus_name_;
     std::string const service_id_;
+    unity::storage::internal::TraceMessageHandler trace_message_handler_;
 
     std::unique_ptr<QCoreApplication> app_;
     std::unique_ptr<OnlineAccounts::Manager> manager_;
 
=== modified file 'include/unity/storage/provider/internal/TempfileUploadJobImpl.h'
--- include/unity/storage/provider/internal/TempfileUploadJobImpl.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/TempfileUploadJobImpl.h	2016-09-09 02:13:43 +0000
@@ -20,8 +20,12 @@
 
 #include <unity/storage/provider/internal/UploadJobImpl.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
 #include <QLocalSocket>
 #include <QTemporaryFile>
+#pragma GCC diagnostic pop
 
 #include <memory>
 #include <string>
@@ -43,6 +47,7 @@
     virtual ~TempfileUploadJobImpl();
 
     void complete_init() override;
+    void drain();
 
     std::string file_name() const;
 
@@ -51,8 +56,8 @@
     void on_read_channel_finished();
 
 private:
+    std::unique_ptr<QTemporaryFile> tmpfile_;
     std::unique_ptr<QLocalSocket> reader_;
-    std::unique_ptr<QTemporaryFile> tmpfile_;
 
     Q_DISABLE_COPY(TempfileUploadJobImpl)
 };
 
=== added file 'include/unity/storage/provider/internal/TestServerImpl.h'
--- include/unity/storage/provider/internal/TestServerImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/internal/TestServerImpl.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/provider/testing/TestServer.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#include <QDBusConnection>
+#pragma GCC diagnostic pop
+
+#include <memory>
+#include <string>
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+namespace internal
+{
+
+class ProviderInterface;
+
+class TestServerImpl
+{
+public:
+    TestServerImpl(std::unique_ptr<ProviderBase>&& provider,
+                   OnlineAccounts::Account* account,
+                   QDBusConnection const& connection,
+                   std::string const& object_path);
+    ~TestServerImpl();
+
+    QDBusConnection const& connection() const;
+    std::string const& object_path() const;
+
+private:
+    QDBusConnection connection_;
+    std::string const object_path_;
+
+    std::unique_ptr<ProviderInterface> interface_;
+};
+
+}
+}
+}
+}
 
=== modified file 'include/unity/storage/provider/internal/UploadJobImpl.h'
--- include/unity/storage/provider/internal/UploadJobImpl.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/UploadJobImpl.h	2016-09-09 02:13:43 +0000
@@ -21,7 +21,11 @@
 #include <unity/storage/provider/ProviderBase.h>
 
 #include <boost/thread/future.hpp>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wswitch-default"
 #include <QObject>
+#pragma GCC diagnostic pop
 
 #include <exception>
 #include <mutex>
@@ -49,9 +53,6 @@
     int read_socket() const;
     int take_write_socket();
 
-    std::string const& sender_bus_name() const;
-    void set_sender_bus_name(std::string const& bus_name);
-
     void report_error(std::exception_ptr p);
     boost::future<Item> finish(UploadJob& job);
     boost::future<void> cancel(UploadJob& job);
@@ -63,7 +64,6 @@
     std::string const upload_id_;
     int read_socket_ = -1;
     int write_socket_ = -1;
-    std::string sender_bus_name_;
 
     std::mutex completion_lock_;
     bool completed_ = false;
 
=== modified file 'include/unity/storage/provider/internal/dbusmarshal.h'
--- include/unity/storage/provider/internal/dbusmarshal.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/provider/internal/dbusmarshal.h	2016-09-09 02:13:43 +0000
@@ -18,8 +18,15 @@
 
 #pragma once
 
+#include <unity/storage/provider/ProviderBase.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
 #include <QDBusArgument>
 #include <QVariant>
+#pragma GCC diagnostic pop
+
 #include <vector>
 
 namespace unity
 
=== renamed file 'include/unity/storage/internal/MetadataKeys.h' => 'include/unity/storage/provider/metadata_keys.h'
--- include/unity/storage/internal/MetadataKeys.h	2016-07-14 00:25:40 +0000
+++ include/unity/storage/provider/metadata_keys.h	2016-09-09 02:13:43 +0000
@@ -18,15 +18,28 @@
 
 #pragma once
 
+#include <unordered_map>
+
 namespace unity
 {
 namespace storage
 {
-namespace internal
-{
-
-static char constexpr CREATION_TIME[] = "creation_time";
-
-}  // namespace internal
+namespace provider
+{
+
+static char constexpr SIZE_IN_BYTES[] = "size_in_bytes";            // int64_t, >= 0
+static char constexpr CREATION_TIME[] = "creation_time";            // String, ISO 8601 format
+static char constexpr LAST_MODIFIED_TIME[] = "last_modified_time";  // String, ISO 8601 format
+
+enum class MetadataType { int64, iso_8601_date_time };
+
+static std::unordered_map<std::string, MetadataType> known_metadata =
+{
+    { SIZE_IN_BYTES, MetadataType::int64 },
+    { CREATION_TIME, MetadataType::iso_8601_date_time },
+    { LAST_MODIFIED_TIME, MetadataType::iso_8601_date_time }
+};
+
+}  // namespace provider
 }  // namespace storage
 }  // namespace unity
 
=== added directory 'include/unity/storage/provider/testing'
=== added file 'include/unity/storage/provider/testing/CMakeLists.txt'
--- include/unity/storage/provider/testing/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/testing/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -0,0 +1,5 @@
+set(includeprefix unity/storage/provider/testing)
+file(GLOB provider_headers *.h)
+
+install(FILES ${provider_headers}
+  DESTINATION ${provider_base_includedir}/${includeprefix})
 
=== added file 'include/unity/storage/provider/testing/TestServer.h'
--- include/unity/storage/provider/testing/TestServer.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/testing/TestServer.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/visibility.h>
+
+#include <memory>
+#include <string>
+
+namespace OnlineAccounts
+{
+class Account;
+}
+class QDBusConnection;
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+
+class ProviderBase;
+
+namespace internal
+{
+class TestServerImpl;
+}
+
+namespace testing
+{
+
+class UNITY_STORAGE_EXPORT TestServer
+{
+public:
+    TestServer(std::unique_ptr<ProviderBase>&& provider,
+               OnlineAccounts::Account* account,
+               QDBusConnection const& connection,
+               std::string const& object_path);
+    ~TestServer();
+
+    QDBusConnection const& connection() const;
+    std::string const& object_path() const;
+
+private:
+    std::unique_ptr<internal::TestServerImpl> p_;
+};
+
+}
+}
+}
+}
 
=== modified file 'include/unity/storage/qt/client/Account.h'
--- include/unity/storage/qt/client/Account.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/Account.h	2016-09-09 02:13:43 +0000
@@ -77,7 +77,7 @@
 
     typedef std::shared_ptr<Account> SPtr;
 
-    Runtime* runtime() const;
+    std::shared_ptr<Runtime> runtime() const;
 
     QString owner() const;
     QString owner_id() const;
 
=== modified file 'include/unity/storage/qt/client/Exceptions.h'
--- include/unity/storage/qt/client/Exceptions.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/Exceptions.h	2016-09-09 02:13:43 +0000
@@ -20,7 +20,10 @@
 
 #include <unity/storage/visibility.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
 #include <QException>
+#pragma GCC diagnostic pop
 #include <QString>
 
 namespace unity
@@ -46,6 +49,8 @@
 
     virtual char const* what() const noexcept override;
 
+    QString error_message() const;
+
 private:
     std::string what_string_;
     QString error_message_;
@@ -83,18 +88,16 @@
 class UNITY_STORAGE_EXPORT DeletedException : public StorageException
 {
 public:
-    DeletedException(QString const& error_message, QString const& identity_, QString const& name_);
+    DeletedException(QString const& error_message, QString const& identity_);
     ~DeletedException();
 
     virtual DeletedException* clone() const override;
     virtual void raise() const override;
 
     QString native_identity() const;
-    QString name() const;
 
 private:
     QString identity_;
-    QString name_;
 };
 
 /**
@@ -228,17 +231,22 @@
 };
 
 /**
-\brief Indicates a system error, such as failure to to create a file or folder,
+\brief Indicates a system error, such as failure to create a file or folder,
 or any other (usually non-recoverable) kind of error that should not arise during normal operation.
 */
 class UNITY_STORAGE_EXPORT ResourceException : public StorageException
 {
 public:
-    ResourceException(QString const& error_message);
+    ResourceException(QString const& error_message, int error_code);
     ~ResourceException();
 
     virtual ResourceException* clone() const override;
     virtual void raise() const override;
+
+    int error_code() const noexcept;
+
+private:
+    int error_code_;
 };
 
 }  // namespace client
 
=== modified file 'include/unity/storage/qt/client/Item.h'
--- include/unity/storage/qt/client/Item.h	2016-07-22 02:45:24 +0000
+++ include/unity/storage/qt/client/Item.h	2016-09-09 02:13:43 +0000
@@ -103,7 +103,7 @@
 
     If this item is a root, the returned pointer points at this item.
     */
-    Root* root() const;
+    std::shared_ptr<Root> root() const;
 
     /**
     \brief Returns the type of the item.
 
=== modified file 'include/unity/storage/qt/client/Root.h'
--- include/unity/storage/qt/client/Root.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/qt/client/Root.h	2016-09-09 02:13:43 +0000
@@ -70,7 +70,7 @@
     /**
     \brief Returns the account for this root.
     */
-    Account* account() const;
+    std::shared_ptr<Account> account() const;
 
     QFuture<int64_t> free_space_bytes() const;
     QFuture<int64_t> used_space_bytes() const;
 
=== modified file 'include/unity/storage/qt/client/Runtime.h'
--- include/unity/storage/qt/client/Runtime.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/Runtime.h	2016-09-09 02:13:43 +0000
@@ -44,6 +44,7 @@
 namespace internal
 {
 
+class AccountBase;
 class RuntimeBase;
 
 namespace remote_client
@@ -95,11 +96,23 @@
 
     QFuture<QVector<std::shared_ptr<Account>>> accounts();
 
+    /// @cond
+    /**
+    \brief Creates an Account object pointing at (bus_name, object_path)
+
+    This method is intended for use in tests, where you want to talk
+    to a provider that has already been set up on the bus.
+    */
+    std::shared_ptr<Account> make_test_account(QString const& bus_name,
+                                               QString const& object_path);
+    /// @endcond
+
 private:
     Runtime(internal::RuntimeBase* p) UNITY_STORAGE_HIDDEN;
 
     std::shared_ptr<internal::RuntimeBase> p_;
 
+    friend class internal::AccountBase;
     friend class internal::remote_client::AccountImpl;
 };
 
 
=== modified file 'include/unity/storage/qt/client/Uploader.h'
--- include/unity/storage/qt/client/Uploader.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/Uploader.h	2016-09-09 02:13:43 +0000
@@ -92,6 +92,14 @@
     std::shared_ptr<QLocalSocket> socket() const;
 
     /**
+    \brief Returns the size that was passed to Folder::create_file() or File::create_uploader().
+
+    \return The number of bytes that the uploader expects to be written to the `QLocalSocket` returned
+    from socket().
+    */
+    int64_t size() const;
+
+    /**
     \brief Finalizes the upload.
 
     Once you have written the file contents to the socket returned by socket(), you must call finish_upload(),
 
=== modified file 'include/unity/storage/qt/client/internal/AccountBase.h'
--- include/unity/storage/qt/client/internal/AccountBase.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/internal/AccountBase.h	2016-09-09 02:13:43 +0000
@@ -52,7 +52,7 @@
     AccountBase(AccountBase const&) = delete;
     AccountBase& operator=(AccountBase const&) = delete;
 
-    Runtime* runtime() const;
+    std::shared_ptr<Runtime> runtime() const;
     virtual QString owner() const = 0;
     virtual QString owner_id() const = 0;
     virtual QString description() const = 0;
 
=== modified file 'include/unity/storage/qt/client/internal/ItemBase.h'
--- include/unity/storage/qt/client/internal/ItemBase.h	2016-07-27 02:19:17 +0000
+++ include/unity/storage/qt/client/internal/ItemBase.h	2016-09-09 02:13:43 +0000
@@ -20,10 +20,10 @@
 
 #include <unity/storage/common.h>
 
-#include <QDateTime>
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-align"
 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#include <QDateTime>
 #include <QFuture>
 #pragma GCC diagnostic pop
 #include <QVariantMap>
@@ -60,7 +60,7 @@
 
     QString native_identity() const;
     ItemType type() const;
-    Root* root() const;
+    std::shared_ptr<Root> root() const;
 
     virtual QString name() const = 0;
     virtual QString etag() const = 0;
@@ -82,10 +82,14 @@
     void set_public_instance(std::weak_ptr<Item> p);
 
 protected:
+    std::shared_ptr<Root> get_root() const noexcept;
+    void throw_if_destroyed(QString const& method) const;
+
     const QString identity_;
     const ItemType type_;
     std::weak_ptr<Root> root_;
     std::weak_ptr<Item> public_instance_;
+    bool deleted_ = false;
 
     friend class ItemImpl;
 };
 
=== modified file 'include/unity/storage/qt/client/internal/RootBase.h'
--- include/unity/storage/qt/client/internal/RootBase.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/qt/client/internal/RootBase.h	2016-09-09 02:13:43 +0000
@@ -46,7 +46,7 @@
 public:
     RootBase(QString const& identity, std::weak_ptr<Account> const& account);
 
-    Account* account() const;
+    std::shared_ptr<Account> account() const;
     virtual QFuture<int64_t> free_space_bytes() const = 0;
     virtual QFuture<int64_t> used_space_bytes() const = 0;
     virtual QFuture<Item::SPtr> get(QString native_identity) const = 0;
 
=== modified file 'include/unity/storage/qt/client/internal/RuntimeBase.h'
--- include/unity/storage/qt/client/internal/RuntimeBase.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/internal/RuntimeBase.h	2016-09-09 02:13:43 +0000
@@ -25,7 +25,6 @@
 #pragma GCC diagnostic pop
 #include <QVector>
 
-#include <atomic>
 #include <memory>
 
 namespace unity
@@ -43,23 +42,29 @@
 namespace internal
 {
 
+class AccountBase;
+
 class RuntimeBase : public QObject
 {
 public:
-    RuntimeBase();
+    RuntimeBase() = default;
     virtual ~RuntimeBase() = default;
     RuntimeBase(RuntimeBase const&) = delete;
     RuntimeBase& operator=(RuntimeBase const&) = delete;
 
     virtual void shutdown() = 0;
     virtual QFuture<QVector<std::shared_ptr<Account>>> accounts() = 0;
+    virtual std::shared_ptr<Account> make_test_account(QString const& bus_name,
+                                                       QString const& object_path) = 0;
 
     void set_public_instance(std::weak_ptr<Runtime> p);
 
 protected:
-    std::atomic_bool destroyed_;
-    QVector<std::shared_ptr<Account>> accounts_;  // Immutable once set
+    bool destroyed_ = false;
+    QVector<std::shared_ptr<Account>> accounts_;
     std::weak_ptr<Runtime> public_instance_;      // Immutable once set
+
+    friend class unity::storage::qt::client::internal::AccountBase;
 };
 
 }  // namespace internal
 
=== modified file 'include/unity/storage/qt/client/internal/UploaderBase.h'
--- include/unity/storage/qt/client/internal/UploaderBase.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/internal/UploaderBase.h	2016-09-09 02:13:43 +0000
@@ -47,7 +47,7 @@
 class UploaderBase : public QObject
 {
 public:
-    UploaderBase(ConflictPolicy policy);
+    UploaderBase(ConflictPolicy policy, int64_t size);
     UploaderBase(UploaderBase&) = delete;
     UploaderBase& operator=(UploaderBase const&) = delete;
 
@@ -55,8 +55,11 @@
     virtual QFuture<std::shared_ptr<File>> finish_upload() = 0;
     virtual QFuture<void> cancel() noexcept = 0;
 
+    int64_t size() const;
+
 protected:
     ConflictPolicy policy_;
+    int64_t size_;
 };
 
 }  // namespace internal
 
=== modified file 'include/unity/storage/qt/client/internal/local_client/DownloaderImpl.h'
--- include/unity/storage/qt/client/internal/local_client/DownloaderImpl.h	2016-07-14 04:50:36 +0000
+++ include/unity/storage/qt/client/internal/local_client/DownloaderImpl.h	2016-09-09 02:13:43 +0000
@@ -60,7 +60,7 @@
 
 private:
     void read_and_write_chunk();
-    void handle_error(QString const& msg);
+    void handle_error(QString const& msg, int error_code);
 
     enum State { in_progress, finalized, cancelled, error };
 
@@ -73,6 +73,7 @@
     QFutureInterface<void>& worker_initialized_;
     qint64 bytes_to_write_;
     QString error_msg_;
+    int error_code_ = 0;
 };
 
 class DownloadThread : public QThread
 
=== modified file 'include/unity/storage/qt/client/internal/local_client/FolderImpl.h'
--- include/unity/storage/qt/client/internal/local_client/FolderImpl.h	2016-07-14 00:17:14 +0000
+++ include/unity/storage/qt/client/internal/local_client/FolderImpl.h	2016-09-09 02:13:43 +0000
@@ -40,6 +40,7 @@
     FolderImpl(QString const& identity);
     FolderImpl(QString const& identity, ItemType type);
 
+    virtual QString name() const override;
     QFuture<QVector<std::shared_ptr<Item>>> list() const override;
     QFuture<QVector<std::shared_ptr<Item>>> lookup(QString const& name) const override;
     QFuture<std::shared_ptr<Folder>> create_folder(QString const& name) override;
 
=== modified file 'include/unity/storage/qt/client/internal/local_client/ItemImpl.h'
--- include/unity/storage/qt/client/internal/local_client/ItemImpl.h	2016-07-27 02:19:17 +0000
+++ include/unity/storage/qt/client/internal/local_client/ItemImpl.h	2016-09-09 02:13:43 +0000
@@ -47,7 +47,6 @@
     ItemImpl(QString const& identity, ItemType type);
     virtual ~ItemImpl();
 
-    virtual QString name() const override;
     virtual QString etag() const override;
     virtual QVariantMap metadata() const override;
     virtual QDateTime last_modified_time() const override;
@@ -65,20 +64,18 @@
     void set_timestamps() noexcept;
     bool has_conflict() const noexcept;
 
-    std::unique_lock<std::mutex> get_lock();
-
 protected:
     static boost::filesystem::path sanitize(QString const& name, QString const& method);
     static bool is_reserved_path(boost::filesystem::path const& path) noexcept;
 
-    DeletedException deleted_ex(QString const& method) const noexcept;
-
-    bool deleted_;
     QString name_;
     QString etag_;
     QDateTime modified_time_;
     QVariantMap metadata_;
-    std::mutex mutable mutex_;
+    std::recursive_mutex mutable mutex_;
+
+private:
+    static void copy_recursively(boost::filesystem::path const& source, boost::filesystem::path const& target);
 };
 
 }  // namespace local_client
 
=== modified file 'include/unity/storage/qt/client/internal/local_client/RuntimeImpl.h'
--- include/unity/storage/qt/client/internal/local_client/RuntimeImpl.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/qt/client/internal/local_client/RuntimeImpl.h	2016-09-09 02:13:43 +0000
@@ -41,6 +41,8 @@
 
     virtual void shutdown() override;
     virtual QFuture<QVector<std::shared_ptr<Account>>> accounts() override;
+    virtual std::shared_ptr<Account> make_test_account(QString const& bus_name,
+                                                       QString const& object_path) override;
 };
 
 }  // namespace local_client
 
=== modified file 'include/unity/storage/qt/client/internal/local_client/UploaderImpl.h'
--- include/unity/storage/qt/client/internal/local_client/UploaderImpl.h	2016-07-26 01:51:26 +0000
+++ include/unity/storage/qt/client/internal/local_client/UploaderImpl.h	2016-09-09 02:13:43 +0000
@@ -68,12 +68,11 @@
 private Q_SLOTS:
     void on_bytes_ready();
     void on_read_channel_finished();
-    void on_error();
 
 private:
     void read_and_write_chunk();
     void finalize();
-    void handle_error(QString const& msg);
+    void handle_error(QString const& msg, int error_code);
 
     enum State { in_progress, finalized, cancelled, error };
 
@@ -91,6 +90,7 @@
     QFutureInterface<std::shared_ptr<File>>& qf_;
     QFutureInterface<void>& worker_initialized_;
     QString error_msg_;
+    int error_code_ = 0;
     bool use_linkat_ = true;
 };
 
 
=== added file 'include/unity/storage/qt/client/internal/local_client/storage_exception.h'
--- include/unity/storage/qt/client/internal/local_client/storage_exception.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/qt/client/internal/local_client/storage_exception.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/qt/client/Exceptions.h>
+#include <unity/storage/qt/client/internal/local_client/boost_filesystem.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wcast-align"
+#include <QFuture>
+#pragma GCC diagnostic pop
+#include <QFutureInterface>
+
+class QString;
+
+namespace unity
+{
+namespace storage
+{
+namespace qt
+{
+namespace client
+{
+namespace internal
+{
+namespace local_client
+{
+
+void throw_storage_exception(QString const& method,
+                             std::exception_ptr ep) __attribute__ ((noreturn));
+
+void throw_storage_exception(QString const& method,
+                             std::exception_ptr ep,
+                             QString const& key) __attribute__ ((noreturn));
+
+template<typename T>
+QFuture<T> make_exceptional_future(QString const& method, std::exception_ptr ep)
+{
+    try
+    {
+        throw_storage_exception(method, ep);
+    }
+    catch (StorageException const& e)
+    {
+        QFutureInterface<T> qf;
+        qf.reportException(e);
+        qf.reportFinished();
+        return qf.future();
+    }
+    abort();  // Impossible.  // LCOV_EXCL_LINE
+}
+
+template<typename T>
+QFuture<T> make_exceptional_future(QString const& method,
+                                   std::exception_ptr ep,
+                                   QString const& key)
+{
+    try
+    {
+        throw_storage_exception(method, ep, key);
+    }
+    catch (StorageException const& e)
+    {
+        QFutureInterface<T> qf;
+        qf.reportException(e);
+        qf.reportFinished();
+        return qf.future();
+    }
+    abort();  // Impossible.  // LCOV_EXCL_LINE
+}
+
+}  // namespace local_client
+}  // namespace internal
+}  // namespace client
+}  // namespace qt
+}  // namespace storage
+}  // namespace unity
 
=== renamed file 'include/unity/storage/qt/client/internal/local_client/tmpfile-prefix.h' => 'include/unity/storage/qt/client/internal/local_client/tmpfile_prefix.h'
=== modified file 'include/unity/storage/qt/client/internal/make_future.h'
--- include/unity/storage/qt/client/internal/make_future.h	2016-07-22 02:35:12 +0000
+++ include/unity/storage/qt/client/internal/make_future.h	2016-09-09 02:13:43 +0000
@@ -36,40 +36,30 @@
 namespace internal
 {
 
+template<typename T>
+QFuture<T>
+__attribute__ ((warn_unused_result))
+make_ready_future(T const& val)
+{
+    QFutureInterface<T> qf;
+    qf.reportResult(val);
+    qf.reportFinished();
+    return qf.future();
+}
+
 template<typename T = void>
-QFuture<T> make_ready_future()
+QFuture<T>
+__attribute__ ((warn_unused_result))
+make_ready_future()
 {
     QFutureInterface<void> qf;
-    qf.reportFinished();
-    return qf.future();
-}
-
-template<typename T = void>
-QFuture<T> make_ready_future(QFutureInterface<T> qf)
-{
-    qf.reportFinished();
-    return qf.future();
-}
-
-template<typename T>
-QFuture<T> make_ready_future(T const& val)
-{
-    QFutureInterface<T> qf;
-    qf.reportResult(val);
-    qf.reportFinished();
-    return qf.future();
-}
-
-template<typename T>
-QFuture<T> make_ready_future(QFutureInterface<T> qf, T const& val)
-{
-    qf.reportResult(val);
-    qf.reportFinished();
-    return qf.future();
+    return make_ready_future(qf);
 }
 
 template<typename E>
-QFuture<void> make_exceptional_future(E const& ex)
+QFuture<void>
+__attribute__
+((warn_unused_result)) make_exceptional_future(E const& ex)
 {
     QFutureInterface<void> qf;
     qf.reportException(ex);
@@ -78,7 +68,9 @@
 }
 
 template<typename T, typename E>
-QFuture<T> make_exceptional_future(E const& ex)
+QFuture<T>
+__attribute__ ((warn_unused_result))
+make_exceptional_future(E const& ex)
 {
     QFutureInterface<T> qf;
     qf.reportException(ex);
@@ -86,14 +78,6 @@
     return qf.future();
 }
 
-template<typename T, typename E>
-QFuture<T> make_exceptional_future(QFutureInterface<T> qf, E const& ex)
-{
-    qf.reportException(ex);
-    qf.reportFinished();
-    return qf.future();
-}
-
 }  // namespace internal
 }  // namespace client
 }  // namespace qt
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/AccountImpl.h'
--- include/unity/storage/qt/client/internal/remote_client/AccountImpl.h	2016-07-15 03:56:14 +0000
+++ include/unity/storage/qt/client/internal/remote_client/AccountImpl.h	2016-09-09 02:13:43 +0000
@@ -39,7 +39,8 @@
 {
 public:
     AccountImpl(std::weak_ptr<Runtime> const& runtime,
-                int account_id,
+                QString const& bus_name,
+                QString const& object_path,
                 QString const& owner,
                 QString const& owner_id,
                 QString const& description);
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/Handler.h'
--- include/unity/storage/qt/client/internal/remote_client/Handler.h	2016-07-15 03:58:35 +0000
+++ include/unity/storage/qt/client/internal/remote_client/Handler.h	2016-09-09 02:13:43 +0000
@@ -20,10 +20,13 @@
 
 #include <unity/storage/qt/client/Exceptions.h>
 #include <unity/storage/qt/client/internal/make_future.h>
+#include <unity/storage/qt/client/internal/remote_client/dbusmarshal.h>
 #include <unity/storage/qt/client/internal/remote_client/HandlerBase.h>
 
 #include <QDBusPendingReply>
 
+#include <cassert>
+
 namespace unity
 {
 namespace storage
@@ -72,8 +75,41 @@
                       {
                           if (call.isError())
                           {
-                              qDebug() << call.error().message();  // TODO, remove this
-                              make_exceptional_future<T>(ResourceException("DBus error return"));
+                              try
+                              {
+                                  auto ep = unmarshal_exception(call);
+                                  std::rethrow_exception(ep);
+                              }
+                              // We catch some exceptions that are "surprising" so we can log those.
+                              catch (LocalCommsException const& e)
+                              {
+                                  qCritical() << "provider exception:" << e.what();
+                                  qf_.reportException(e);
+                                  qf_.reportFinished();
+                              }
+                              catch (RemoteCommsException const& e)
+                              {
+                                  qCritical() << "provider exception:" << e.what();
+                                  qf_.reportException(e);
+                                  qf_.reportFinished();
+                              }
+                              catch (ResourceException const& e)
+                              {
+                                  qCritical() << "provider exception:" << e.what();
+                                  qf_.reportException(e);
+                                  qf_.reportFinished();
+                              }
+                              catch (StorageException const& e)
+                              {
+                                  qf_.reportException(e);
+                                  qf_.reportFinished();
+                              }
+                              // LCOV_EXCL_START
+                              catch (...)
+                              {
+                                  abort();  // Impossible.
+                              }
+                              // LCOV_EXCL_STOP
                               return;
                           }
                           // TODO: See HACK above. Should just be closure(call, qf_);
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/ItemImpl.h'
--- include/unity/storage/qt/client/internal/remote_client/ItemImpl.h	2016-07-22 00:17:24 +0000
+++ include/unity/storage/qt/client/internal/remote_client/ItemImpl.h	2016-09-09 02:13:43 +0000
@@ -66,9 +66,6 @@
     static std::shared_ptr<Item> make_item(storage::internal::ItemMetadata const& md, std::weak_ptr<Root> root);
 
 protected:
-    DeletedException deleted_ex(QString const& method) const noexcept;
-
-    bool deleted_ = false;
     storage::internal::ItemMetadata md_;
 
     friend class DeleteHandler;
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/RuntimeImpl.h'
--- include/unity/storage/qt/client/internal/remote_client/RuntimeImpl.h	2016-07-22 00:17:24 +0000
+++ include/unity/storage/qt/client/internal/remote_client/RuntimeImpl.h	2016-09-09 02:13:43 +0000
@@ -50,6 +50,8 @@
 
     virtual void shutdown() override;
     virtual QFuture<QVector<std::shared_ptr<Account>>> accounts() override;
+    virtual std::shared_ptr<Account> make_test_account(QString const& bus_name,
+                                                       QString const& object_path) override;
 
     QDBusConnection& connection();
 
@@ -58,6 +60,12 @@
     virtual void timeout();
 
 private:
+    std::shared_ptr<Account> make_account(QString const& bus_name,
+                                          QString const& object_path,
+                                          QString const& owner,
+                                          QString const& owner_id,
+                                          QString const& description);
+
     QDBusConnection conn_;
     std::unique_ptr<OnlineAccounts::Manager> manager_;  // TODO: Hack until we can use the registry
     QTimer timer_;
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/UploaderImpl.h'
--- include/unity/storage/qt/client/internal/remote_client/UploaderImpl.h	2016-07-22 00:17:24 +0000
+++ include/unity/storage/qt/client/internal/remote_client/UploaderImpl.h	2016-09-09 02:13:43 +0000
@@ -65,13 +65,15 @@
                                                    std::shared_ptr<ProviderInterface> const& provider);
 
 private:
+    enum State { uploading, finalized };
+
     QString upload_id_;
     QDBusUnixFileDescriptor fd_;
-    int64_t size_;
     QString old_etag_;
-    std::weak_ptr<Root> root_;
+    std::shared_ptr<Root> root_;
     std::shared_ptr<ProviderInterface> provider_;
     std::shared_ptr<QLocalSocket> write_socket_;
+    State state_;
 };
 
 }  // namespace remote_client
 
=== modified file 'include/unity/storage/qt/client/internal/remote_client/dbusmarshal.h'
--- include/unity/storage/qt/client/internal/remote_client/dbusmarshal.h	2016-07-12 02:22:05 +0000
+++ include/unity/storage/qt/client/internal/remote_client/dbusmarshal.h	2016-09-09 02:13:43 +0000
@@ -18,29 +18,28 @@
 
 #pragma once
 
-#include <unity/storage/internal/ItemMetadata.h>
+#include <exception>
 
-#include <QDBusArgument>
-#include <QMetaType>
-#include <QVariant>
+class QDBusPendingCallWatcher;
 
 namespace unity
 {
 namespace storage
 {
+namespace qt
+{
+namespace client
+{
 namespace internal
 {
-
-struct ItemMetadata;
-QDBusArgument& operator<<(QDBusArgument& argument, storage::internal::ItemMetadata const& metadata);
-QDBusArgument const& operator>>(QDBusArgument const& argument, storage::internal::ItemMetadata& metadata);
-
-QDBusArgument& operator<<(QDBusArgument& argument, QList<storage::internal::ItemMetadata> const& md_list);
-QDBusArgument const& operator>>(QDBusArgument const& argument, QList<storage::internal::ItemMetadata>& md_list);
-
+namespace remote_client
+{
+
+std::exception_ptr unmarshal_exception(QDBusPendingCallWatcher const& call);
+
+}  // namespace remote_client
 }  // namespace internal
-}  // namespace storage
-}  // namespace unity
-
-Q_DECLARE_METATYPE(unity::storage::internal::ItemMetadata)
-Q_DECLARE_METATYPE(QList<unity::storage::internal::ItemMetadata>)
+}  // client
+}  // qt
+}  // storage
+}  // unity
 
=== added file 'include/unity/storage/qt/client/internal/remote_client/validate.h'
--- include/unity/storage/qt/client/internal/remote_client/validate.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/qt/client/internal/remote_client/validate.h	2016-09-09 02:13:43 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <QString>
+
+namespace unity
+{
+namespace storage
+{
+
+namespace internal
+{
+
+class ItemMetadata;
+
+}  // namespace internal
+
+namespace qt
+{
+namespace client
+{
+namespace internal
+{
+namespace remote_client
+{
+
+void validate(QString const& method, unity::storage::internal::ItemMetadata const& md);
+
+}  // namespace remote_client
+}  // namespace internal
+}  // namespace client
+}  // namespace qt
+}  // namespace storage
+}  // namespace unity
 
=== modified file 'src/internal/CMakeLists.txt'
--- src/internal/CMakeLists.txt	2016-07-06 00:59:42 +0000
+++ src/internal/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -1,5 +1,10 @@
 set(src
+    dbusmarshal.cpp
     safe_strerror.cpp
+    TraceMessageHandler.cpp
 )
 
 add_library(storage-framework-common-internal STATIC ${src})
+target_link_libraries(storage-framework-common-internal
+    Qt5::DBus
+)
 
=== added file 'src/internal/TraceMessageHandler.cpp'
--- src/internal/TraceMessageHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/internal/TraceMessageHandler.cpp	2016-09-09 02:13:43 +0000
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#include <unity/storage/internal/TraceMessageHandler.h>
+
+#include <chrono>
+#include <mutex>
+
+using namespace std;
+
+namespace unity
+{
+namespace storage
+{
+namespace internal
+{
+namespace
+{
+
+string prefix;
+
+void trace_message_handler(QtMsgType type, const QMessageLogContext& /*context*/, const QString& msg)
+{
+    using namespace std;
+    using namespace std::chrono;
+
+    static recursive_mutex mutex;
+    lock_guard<decltype(mutex)> lock(mutex);
+
+    auto now = system_clock::now();
+    auto sys_time = system_clock::to_time_t(now);
+    struct tm local_time;
+    localtime_r(&sys_time, &local_time);
+    int msecs = duration_cast<milliseconds>(now.time_since_epoch()).count() % 1000;
+
+    if (!prefix.empty())
+    {
+        fprintf(stderr, "%s: ", prefix.c_str());
+    }
+    char buf[100];
+    strftime(buf, sizeof(buf), "%T", &local_time);
+    fprintf(stderr, "[%s.%03d]", buf, msecs);
+    switch (type)
+    {
+        case QtWarningMsg:
+            fputs(" Warning:", stderr);
+            break;
+        case QtCriticalMsg:
+            fputs(" Critical:", stderr);
+            break;
+        // LCOV_EXCL_START
+        case QtFatalMsg:
+            fputs(" Fatal:", stderr);
+            break;
+        // LCOV_EXCL_STOP
+        default:
+            break;  // No label for debug messages.
+    }
+    fprintf(stderr, " %s\n", msg.toLocal8Bit().constData());
+    if (type == QtFatalMsg)
+    {
+        abort();  // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace
+
+TraceMessageHandler::TraceMessageHandler(string const& prog_name)
+{
+    prefix = prog_name;
+    old_message_handler_ = qInstallMessageHandler(trace_message_handler);
+}
+
+TraceMessageHandler::~TraceMessageHandler()
+{
+    qInstallMessageHandler(old_message_handler_);
+}
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace unity
 
=== added file 'src/internal/dbusmarshal.cpp'
--- src/internal/dbusmarshal.cpp	1970-01-01 00:00:00 +0000
+++ src/internal/dbusmarshal.cpp	2016-09-09 02:13:43 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#include <unity/storage/internal/dbusmarshal.h>
+
+#include <QDebug>
+
+using namespace unity::storage::internal;
+using namespace std;
+
+namespace unity
+{
+namespace storage
+{
+namespace internal
+{
+
+QDBusArgument& operator<<(QDBusArgument& argument, storage::internal::ItemMetadata const& metadata)
+{
+    argument.beginStructure();
+    argument << metadata.item_id;
+    argument << metadata.parent_ids;
+    argument << metadata.name;
+    argument << metadata.etag;
+    argument << static_cast<int32_t>(metadata.type);
+    argument.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
+    decltype(ItemMetadata::metadata)::const_iterator i = metadata.metadata.constBegin();
+    while (i != metadata.metadata.constEnd())
+    {
+        argument.beginMapEntry();
+        argument << i.key() << QDBusVariant(i.value());
+        argument.endMapEntry();
+        ++i;
+    }
+    argument.endMap();
+    argument.endStructure();
+    return argument;
+}
+
+QDBusArgument const& operator>>(QDBusArgument const& argument, storage::internal::ItemMetadata& metadata)
+{
+    argument.beginStructure();
+    argument >> metadata.item_id;
+    argument >> metadata.parent_ids;
+    argument >> metadata.name;
+    argument >> metadata.etag;
+    int32_t enum_val;
+    argument >> enum_val;
+    if (enum_val < 0 || enum_val >= int(ItemType::LAST_ENTRY__))
+    {
+        qCritical() << "unmarshaling error: impossible ItemType value: " + QString::number(enum_val);
+        return argument;  // Forces error
+    }
+    metadata.type = static_cast<ItemType>(enum_val);
+    metadata.metadata.clear();
+    argument.beginMap();
+    while (!argument.atEnd())
+    {
+        QString key;
+        QVariant value;
+        argument.beginMapEntry();
+        argument >> key >> value;
+        argument.endMapEntry();
+        metadata.metadata.insert(key, value);
+    }
+    argument.endMap();
+    argument.endStructure();
+    return argument;
+}
+
+QDBusArgument& operator<<(QDBusArgument& argument, QList<storage::internal::ItemMetadata> const& md_list)
+{
+    argument.beginArray(qMetaTypeId<storage::internal::ItemMetadata>());
+    for (auto const& md : md_list)
+    {
+        argument << md;
+    }
+    argument.endArray();
+    return argument;
+}
+
+QDBusArgument const& operator>>(QDBusArgument const& argument, QList<storage::internal::ItemMetadata>& md_list)
+{
+    md_list.clear();
+    argument.beginArray();
+    while (!argument.atEnd())
+    {
+        ItemMetadata imd;
+        argument >> imd;
+        md_list.append(imd);
+    }
+    argument.endArray();
+    return argument;
+}
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace unity
 
=== modified file 'src/provider/CMakeLists.txt'
--- src/provider/CMakeLists.txt	2016-07-22 03:29:45 +0000
+++ src/provider/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -1,9 +1,3 @@
-
-add_definitions(
-  -DBOOST_THREAD_VERSION=4
-  -DBOOST_THREAD_PROVIDES_EXECUTORS
-  ${APPARMOR_DEPS_CFLAGS}
-  ${ONLINEACCOUNTS_DEPS_CFLAGS})
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 qt5_add_dbus_adaptor(generated_files ${CMAKE_SOURCE_DIR}/data/provider.xml unity/storage/provider/internal/ProviderInterface.h unity::storage::provider::internal::ProviderInterface)
@@ -12,16 +6,20 @@
 qt5_add_dbus_interface(generated_files bus.xml businterface)
 
 set_source_files_properties(${generated_files} PROPERTIES
-    COMPILE_FLAGS "-Wno-ctor-dtor-privacy -Wmissing-field-initializers"
-    GENERATED TRUE
+  COMPILE_FLAGS "-Wno-ctor-dtor-privacy -Wmissing-field-initializers"
+  GENERATED TRUE
 )
 
-add_library(storage-framework-provider SHARED
+add_custom_target(sf-provider-generated-files DEPENDS ${generated_files})
+
+add_library(sf-provider-objects OBJECT
   DownloadJob.cpp
+  Exceptions.cpp
   ProviderBase.cpp
   Server.cpp
   TempfileUploadJob.cpp
   UploadJob.cpp
+  testing/TestServer.cpp
   internal/AccountData.cpp
   internal/DBusPeerCache.cpp
   internal/DownloadJobImpl.cpp
@@ -31,6 +29,7 @@
   internal/ProviderInterface.cpp
   internal/ServerImpl.cpp
   internal/TempfileUploadJobImpl.cpp
+  internal/TestServerImpl.cpp
   internal/UploadJobImpl.cpp
   internal/dbusmarshal.cpp
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/AccountData.h
@@ -42,6 +41,23 @@
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/ServerImpl.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/TempfileUploadJobImpl.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/UploadJobImpl.h
+)
+add_dependencies(sf-provider-objects sf-provider-generated-files)
+set_target_properties(sf-provider-objects PROPERTIES
+  AUTOMOC TRUE
+)
+target_compile_options(sf-provider-objects PUBLIC
+  -DBOOST_THREAD_VERSION=4
+  -DBOOST_THREAD_PROVIDES_EXECUTORS
+  ${APPARMOR_DEPS_CFLAGS}
+  ${ONLINEACCOUNTS_DEPS_CFLAGS})
+target_include_directories(sf-provider-objects PRIVATE
+  ${Qt5DBus_INCLUDE_DIRS}
+  ${Qt5Network_INCLUDE_DIRS}
+)
+
+add_library(storage-framework-provider SHARED
+  $<TARGET_OBJECTS:sf-provider-objects>
   ${generated_files})
 
 set_target_properties(storage-framework-provider PROPERTIES
@@ -51,7 +67,10 @@
   SOVERSION ${SF_PROVIDER_SOVERSION}
   VERSION ${SF_PROVIDER_LIBVERSION}
 )
+target_compile_options(storage-framework-provider PUBLIC
+  $<TARGET_PROPERTY:sf-provider-objects,COMPILE_OPTIONS>)
 target_link_libraries(storage-framework-provider
+  storage-framework-common-internal
   Qt5::Core
   Qt5::DBus
   Qt5::Network
@@ -60,19 +79,31 @@
   ${ONLINEACCOUNTS_DEPS_LDFLAGS}
 )
 
-# moc does not know how to interpret the preprocessor logic in
-# MainLoopExecutor.h, so we reproduce it here.
-if(Boost_VERSION GREATER "105599")
-  set_target_properties(storage-framework-provider PROPERTIES
-    AUTOMOC_MOC_OPTIONS "-DSF_SUPPORTS_EXECUTORS"
-  )
-endif()
-
 install(
   TARGETS storage-framework-provider
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 )
 
+# Build a static version of the library so that tests have access to
+# hidden visibility symbols.
+add_library(storage-framework-provider-static STATIC
+  $<TARGET_OBJECTS:sf-provider-objects>
+  ${generated_files})
+set_target_properties(storage-framework-provider-static PROPERTIES
+  AUTOMOC TRUE
+  )
+target_compile_options(storage-framework-provider-static PUBLIC
+  $<TARGET_PROPERTY:sf-provider-objects,COMPILE_OPTIONS>)
+target_link_libraries(storage-framework-provider-static
+  storage-framework-common-internal
+  Qt5::Core
+  Qt5::DBus
+  Qt5::Network
+  ${Boost_LIBRARIES}
+  ${APPARMOR_DEPS_LDFLAGS}
+  ${ONLINEACCOUNTS_DEPS_LDFLAGS}
+)
+
 configure_file(
   storage-framework-provider.pc.in
   storage-framework-provider-${SF_PROVIDER_API_VERSION}.pc
 
=== added file 'src/provider/Exceptions.cpp'
--- src/provider/Exceptions.cpp	1970-01-01 00:00:00 +0000
+++ src/provider/Exceptions.cpp	2016-09-09 02:13:43 +0000
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michi Henning <[e-mail]>
+ */
+
+#include <unity/storage/provider/Exceptions.h>
+
+using namespace std;
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+
+StorageException::StorageException(std::string const& exception_type, string const& error_message)
+    : what_string_(string(exception_type) + ": " + error_message)
+    , type_(exception_type)
+    , error_message_(error_message)
+{
+}
+
+StorageException::~StorageException() = default;
+
+char const* StorageException::what() const noexcept
+{
+    return what_string_.c_str();
+}
+
+string StorageException::type() const
+{
+    return type_;
+}
+
+string StorageException::error_message() const
+{
+    return error_message_;
+}
+
+RemoteCommsException::RemoteCommsException(string const& error_message)
+    : StorageException("RemoteCommsException", error_message)
+{
+}
+
+RemoteCommsException::~RemoteCommsException() = default;
+
+NotExistsException::NotExistsException(string const& error_message, string const& key)
+    : StorageException("NotExistsException", error_message)
+    , key_(key)
+{
+}
+
+NotExistsException::~NotExistsException() = default;
+
+string NotExistsException::key() const
+{
+    return key_;
+}
+
+ExistsException::ExistsException(string const& error_message, string const& identity, string const& name)
+    : StorageException("ExistsException", error_message)
+    , identity_(identity)
+    , name_(name)
+{
+}
+
+ExistsException::~ExistsException() = default;
+
+string ExistsException::native_identity() const
+{
+    return identity_;
+}
+
+string ExistsException::name() const
+{
+    return name_;
+}
+
+ConflictException::ConflictException(string const& error_message)
+    : StorageException("ConflictException", error_message)
+{
+}
+
+ConflictException::~ConflictException() = default;
+
+PermissionException::PermissionException(string const& error_message)
+    : StorageException("PermissionException", error_message)
+{
+}
+
+PermissionException::~PermissionException() = default;
+
+QuotaException::QuotaException(string const& error_message)
+    : StorageException("QuotaException", error_message)
+{
+}
+
+QuotaException::~QuotaException() = default;
+
+CancelledException::CancelledException(string const& error_message)
+    : StorageException("CancelledException", error_message)
+{
+}
+
+CancelledException::~CancelledException() = default;
+
+LogicException::LogicException(string const& error_message)
+    : StorageException("LogicException", error_message)
+{
+}
+
+LogicException::~LogicException() = default;
+
+InvalidArgumentException::InvalidArgumentException(string const& error_message)
+    : StorageException("InvalidArgumentException", error_message)
+{
+}
+
+InvalidArgumentException::~InvalidArgumentException() = default;
+
+ResourceException::ResourceException(string const& error_message, int error_code)
+    : StorageException("ResourceException", error_message)
+    , error_code_(error_code)
+{
+}
+
+ResourceException::~ResourceException() = default;
+
+int ResourceException::error_code() const noexcept
+{
+    return error_code_;
+}
+
+UnknownException::UnknownException(string const& error_message)
+    : StorageException("UnknownException", error_message)
+{
+}
+
+UnknownException::~UnknownException() = default;
+
+}  // namespace provider
+}  // namespace storage
+}  // namespace unity
 
=== modified file 'src/provider/TempfileUploadJob.cpp'
--- src/provider/TempfileUploadJob.cpp	2016-07-12 02:22:05 +0000
+++ src/provider/TempfileUploadJob.cpp	2016-09-09 02:13:43 +0000
@@ -40,6 +40,11 @@
 
 TempfileUploadJob::~TempfileUploadJob() = default;
 
+void TempfileUploadJob::drain()
+{
+    static_cast<internal::TempfileUploadJobImpl*>(p_)->drain();
+}
+
 string TempfileUploadJob::file_name() const
 {
     return static_cast<internal::TempfileUploadJobImpl*>(p_)->file_name();
 
=== modified file 'src/provider/internal/DownloadJobImpl.cpp'
--- src/provider/internal/DownloadJobImpl.cpp	2016-07-12 02:22:05 +0000
+++ src/provider/internal/DownloadJobImpl.cpp	2016-09-09 02:13:43 +0000
@@ -17,7 +17,9 @@
  */
 
 #include <unity/storage/provider/internal/DownloadJobImpl.h>
+#include <unity/storage/internal/safe_strerror.h>
 #include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/Exceptions.h>
 
 #include <sys/socket.h>
 #include <sys/types.h>
@@ -26,6 +28,7 @@
 #include <stdexcept>
 
 using namespace std;
+using namespace unity::storage::internal;
 
 namespace unity
 {
@@ -42,18 +45,30 @@
     int socks[2];
     if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) < 0)
     {
-        throw runtime_error("could not create socketpair");
+        int error_code = errno;
+        string msg = "could not create socketpair: " + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
     read_socket_ = socks[0];
     write_socket_ = socks[1];
+
+#if 0
+    // TODO: We should be able to half-close the write channel of the read socket and the read channel of
+    // the write socket. But, if we do, QLocalSocket indicates that everything was closed, which causes
+    // failures on the client side. We suspect a QLocalSocket bug -- need to investigate.
     if (shutdown(read_socket_, SHUT_WR) < 0)
     {
-        throw runtime_error("Could not shut down write channel on read socket");
+        int error_code = errno;
+        string msg = "Could not shut down write channel on read socket" + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
     if (shutdown(write_socket_, SHUT_RD) < 0)
     {
-        throw runtime_error("Could not shut down read channel on write socket");
+        int error_code = errno;
+        string msg = "Could not shut down read channel on write socket: " + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
+#endif
 }
 
 DownloadJobImpl::~DownloadJobImpl()
@@ -90,17 +105,6 @@
     return sock;
 }
 
-string const& DownloadJobImpl::sender_bus_name() const
-{
-    return sender_bus_name_;
-}
-
-void DownloadJobImpl::set_sender_bus_name(string const& bus_name)
-{
-    assert(bus_name[0] == ':');
-    sender_bus_name_ = bus_name;
-}
-
 void DownloadJobImpl::report_complete()
 {
     if (write_socket_ >= 0)
@@ -124,7 +128,19 @@
 
     lock_guard<mutex> guard(completion_lock_);
     completed_ = true;
-    completion_promise_.set_exception(p);
+    // Convert std::exception_ptr to boost::exception_ptr
+    try
+    {
+        std::rethrow_exception(p);
+    }
+    catch (StorageException const& e)
+    {
+        completion_promise_.set_exception(e);
+    }
+    catch (...)
+    {
+        completion_promise_.set_exception(boost::current_exception());
+    }
 }
 
 boost::future<void> DownloadJobImpl::finish(DownloadJob& job)
 
=== modified file 'src/provider/internal/Handler.cpp'
--- src/provider/internal/Handler.cpp	2016-07-20 02:20:53 +0000
+++ src/provider/internal/Handler.cpp	2016-09-09 02:13:43 +0000
@@ -17,20 +17,26 @@
  */
 
 #include <unity/storage/provider/internal/Handler.h>
+
+#include <unity/storage/internal/dbus_error.h>
 #include <unity/storage/provider/internal/AccountData.h>
+#include <unity/storage/provider/internal/dbusmarshal.h>
 #include <unity/storage/provider/internal/DBusPeerCache.h>
 #include <unity/storage/provider/internal/MainLoopExecutor.h>
 #include <unity/storage/provider/ProviderBase.h>
+#include <unity/storage/provider/Exceptions.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#include <QDebug>
+#pragma GCC diagnostic pop
 
 #include <stdexcept>
 
+using namespace unity::storage::internal;
 using namespace std;
 
-namespace
-{
-char const ERROR[] = "com.canonical.StorageFramework.Provider.Error";
-}
-
 namespace unity
 {
 namespace storage
@@ -53,7 +59,8 @@
     auto peer_future = account_->dbus_peer().get(message_.service());
     creds_future_ = peer_future.then(
         EXEC_IN_MAIN
-        [this](decltype(peer_future) f) {
+        [this](decltype(peer_future) f)
+        {
             auto info = f.get();
             if (info.valid)
             {
@@ -64,8 +71,10 @@
             }
             else
             {
-                reply_ = message_.createErrorReply(
-                    ERROR, "Handler::begin(): could not retrieve credentials");
+                string msg = "Handler::begin(): could not retrieve credentials";
+                qDebug() << QString::fromStdString(msg);
+                auto ep = make_exception_ptr(PermissionException(msg));
+                marshal_exception(ep);
                 QMetaObject::invokeMethod(this, "send_reply",
                                           Qt::QueuedConnection);
             }
@@ -75,23 +84,29 @@
 void Handler::credentials_received()
 {
     boost::future<QDBusMessage> msg_future;
-    try {
+    try
+    {
         msg_future = callback_(account_, context_, message_);
-    } catch (std::exception const& e) {
-        reply_ = message_.createErrorReply(ERROR, e.what());
+    }
+    catch (std::exception const& e)
+    {
+        qDebug() << "provider method threw an exception:" << e.what();
+        marshal_exception(current_exception());
         QMetaObject::invokeMethod(this, "send_reply", Qt::QueuedConnection);
         return;
     }
     reply_future_ = msg_future.then(
         EXEC_IN_MAIN
-        [this](decltype(msg_future) f) {
+        [this](decltype(msg_future) f)
+        {
             try
             {
                 reply_ = f.get();
             }
             catch (std::exception const& e)
             {
-                reply_ = message_.createErrorReply(ERROR, e.what());
+                qDebug() << e.what();
+                marshal_exception(current_exception());
             }
             QMetaObject::invokeMethod(this, "send_reply", Qt::QueuedConnection);
         });
@@ -103,6 +118,62 @@
     Q_EMIT finished();
 }
 
+void Handler::marshal_exception(exception_ptr ep)
+{
+    try
+    {
+        rethrow_exception(ep);
+    }
+    catch (StorageException const& e)
+    {
+        reply_ = message_.createErrorReply(QString(DBUS_ERROR_PREFIX) + QString::fromStdString(e.type()),
+                                           QString::fromStdString(e.error_message()));
+        try
+        {
+            throw;
+        }
+        catch (NotExistsException const& e)
+        {
+            reply_ << QVariant(QString::fromStdString(e.key()));
+        }
+        catch (ExistsException const& e)
+        {
+            reply_ << QVariant(QString::fromStdString(e.native_identity()));
+            reply_ << QVariant(QString::fromStdString(e.name()));
+        }
+        catch (ResourceException const& e)
+        {
+            qDebug() << e.what();
+            reply_ << QVariant(e.error_code());
+        }
+        catch (RemoteCommsException const& e)
+        {
+            qDebug() << e.what();
+        }
+        catch (UnknownException const& e)
+        {
+            qDebug() << e.what();
+        }
+        catch (StorageException const&)
+        {
+            // Some other sub-type of StorageException without additional data members,
+            // and we don't want to log this (not surprising) exception.
+        }
+    }
+    catch (std::exception const& e)
+    {
+        QString msg = QString("unknown exception thrown by provider: ") + e.what();
+        qDebug() << msg;
+        reply_ = message_.createErrorReply(QString(DBUS_ERROR_PREFIX) + "UnknownException", msg);
+    }
+    catch (...)
+    {
+        QString msg = "unknown exception thrown by provider";
+        qDebug() << msg;
+        reply_ = message_.createErrorReply(QString(DBUS_ERROR_PREFIX) + "UnknownException", msg);
+    }
+}
+
 }
 }
 }
 
=== modified file 'src/provider/internal/MainLoopExecutor.cpp'
--- src/provider/internal/MainLoopExecutor.cpp	2016-07-19 03:29:15 +0000
+++ src/provider/internal/MainLoopExecutor.cpp	2016-09-09 02:13:43 +0000
@@ -23,8 +23,6 @@
 
 #include <stdexcept>
 
-#ifdef SF_SUPPORTS_EXECUTORS
-
 namespace {
 
 class WorkEvent : public QEvent {
@@ -107,5 +105,3 @@
 }
 }
 }
-
-#endif /* SF_SUPPORTS_EXECUTORS */
 
=== modified file 'src/provider/internal/PendingJobs.cpp'
--- src/provider/internal/PendingJobs.cpp	2016-07-19 03:26:36 +0000
+++ src/provider/internal/PendingJobs.cpp	2016-09-09 02:13:43 +0000
@@ -18,6 +18,7 @@
 
 #include <unity/storage/provider/internal/PendingJobs.h>
 #include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/Exceptions.h>
 #include <unity/storage/provider/UploadJob.h>
 #include <unity/storage/provider/internal/DownloadJobImpl.h>
 #include <unity/storage/provider/internal/MainLoopExecutor.h>
@@ -47,67 +48,79 @@
             this, &PendingJobs::service_disconnected);
 }
 
-PendingJobs::~PendingJobs() = default;
+PendingJobs::~PendingJobs()
+{
+    for (const auto& pair : downloads_)
+    {
+        cancel_job(pair.second, "download " + pair.second->download_id());
+    }
+    for (const auto& pair : uploads_)
+    {
+        cancel_job(pair.second, "upload " + pair.second->upload_id());
+    }
+}
 
-void PendingJobs::add_download(unique_ptr<DownloadJob> &&job)
+void PendingJobs::add_download(QString const& client_bus_name,
+                               unique_ptr<DownloadJob> &&job)
 {
     lock_guard<mutex> guard(lock_);
 
-    assert(!job->p_->sender_bus_name().empty());
-    assert(downloads_.find(job->download_id()) == downloads_.end());
+    assert(!client_bus_name.isEmpty() && client_bus_name[0] == ':');
+    const auto job_id = make_pair(client_bus_name, job->download_id());
+    assert(downloads_.find(job_id) == downloads_.end());
 
     shared_ptr<DownloadJob> j(std::move(job));
-    downloads_.emplace(j->download_id(), j);
-    watch_peer(j->p_->sender_bus_name());
-}
-
-std::shared_ptr<DownloadJob> PendingJobs::get_download(std::string const& download_id)
-{
-    lock_guard<mutex> guard(lock_);
-
-    return downloads_.at(download_id);
-}
-
-std::shared_ptr<DownloadJob> PendingJobs::remove_download(std::string const& download_id)
-{
-    lock_guard<mutex> guard(lock_);
-
-    auto job = downloads_.at(download_id);
-    downloads_.erase(download_id);
-    unwatch_peer(job->p_->sender_bus_name());
+    downloads_.emplace(job_id, j);
+    watch_peer(client_bus_name);
+}
+
+shared_ptr<DownloadJob> PendingJobs::remove_download(QString const& client_bus_name,
+                                                     string const& download_id)
+{
+    lock_guard<mutex> guard(lock_);
+
+    auto it = downloads_.find({client_bus_name, download_id});
+    if (it == downloads_.cend())
+    {
+        throw LogicException("No such download: " + download_id);
+    }
+    auto job = it->second;
+    downloads_.erase(it);
+    unwatch_peer(client_bus_name);
     return job;
 }
 
-void PendingJobs::add_upload(unique_ptr<UploadJob> &&job)
+void PendingJobs::add_upload(QString const& client_bus_name,
+                             unique_ptr<UploadJob> &&job)
 {
     lock_guard<mutex> guard(lock_);
 
-    assert(!job->p_->sender_bus_name().empty());
-    assert(uploads_.find(job->upload_id()) == uploads_.end());
+    assert(!client_bus_name.isEmpty() && client_bus_name[0] == ':');
+    const auto job_id = make_pair(client_bus_name, job->upload_id());
+    assert(uploads_.find(job_id) == uploads_.end());
 
     shared_ptr<UploadJob> j(std::move(job));
-    uploads_.emplace(j->upload_id(), j);
-    watch_peer(j->p_->sender_bus_name());
-}
-
-std::shared_ptr<UploadJob> PendingJobs::get_upload(std::string const& upload_id)
-{
-    lock_guard<mutex> guard(lock_);
-
-    return uploads_.at(upload_id);
-}
-
-std::shared_ptr<UploadJob> PendingJobs::remove_upload(std::string const& upload_id)
-{
-    lock_guard<mutex> guard(lock_);
-
-    auto job = uploads_.at(upload_id);
-    uploads_.erase(upload_id);
-    unwatch_peer(job->p_->sender_bus_name());
+    uploads_.emplace(job_id, j);
+    watch_peer(client_bus_name);
+}
+
+shared_ptr<UploadJob> PendingJobs::remove_upload(QString const& client_bus_name,
+                                                 string const& upload_id)
+{
+    lock_guard<mutex> guard(lock_);
+
+    auto it = uploads_.find({client_bus_name, upload_id});
+    if (it == uploads_.cend())
+    {
+        throw LogicException("No such upload: " + upload_id);
+    }
+    auto job = it->second;
+    uploads_.erase(it);
+    unwatch_peer(client_bus_name);
     return job;
 }
 
-void PendingJobs::watch_peer(string const& bus_name)
+void PendingJobs::watch_peer(QString const& bus_name)
 {
     auto it = services_.find(bus_name);
     if (it != services_.end())
@@ -116,12 +129,12 @@
     }
     else
     {
-        watcher_.addWatchedService(QString::fromStdString(bus_name));
+        watcher_.addWatchedService(bus_name);
         services_[bus_name] = 1;
     }
 }
 
-void PendingJobs::unwatch_peer(string const& bus_name)
+void PendingJobs::unwatch_peer(QString const& bus_name)
 {
     auto it = services_.find(bus_name);
     if (it == services_.end())
@@ -132,72 +145,62 @@
     if (it->second == 0)
     {
         services_.erase(it);
-        watcher_.removeWatchedService(QString::fromStdString(bus_name));
+        watcher_.removeWatchedService(bus_name);
     }
 }
 
 void PendingJobs::service_disconnected(QString const& service_name)
 {
     lock_guard<mutex> guard(lock_);
-    string const bus_name = service_name.toStdString();
-
-    for (auto it = downloads_.cbegin(); it != downloads_.cend(); )
-    {
-        if (it->second->p_->sender_bus_name() == bus_name)
-        {
-            auto job = it->second;
-            it = downloads_.erase(it);
-            auto f = job->p_->cancel(*job);
-            // This continuation also ensures that the job remains
-            // alive until the cancel method has completed.
-            f.then(
-                EXEC_IN_MAIN
-                [job](decltype(f) f) {
-                    try
-                    {
-                        f.get();
-                    }
-                    catch (std::exception const& e)
-                    {
-                        fprintf(stderr, "Error cancelling download job '%s': %s\n",
-                                job->download_id().c_str(), e.what());
-                    }
-                });
-        }
-        else
-        {
-            ++it;
-        }
-    }
-
-    for (auto it = uploads_.cbegin(); it != uploads_.cend(); )
-    {
-        if (it->second->p_->sender_bus_name() == bus_name)
-        {
-            auto job = it->second;
-            it = uploads_.erase(it);
-            auto f = job->p_->cancel(*job);
-            // This continuation also ensures that the job remains
-            // alive until the cancel method has completed.
-            f.then(
-                EXEC_IN_MAIN
-                [job](decltype(f) f) {
-                    try
-                    {
-                        f.get();
-                    }
-                    catch (std::exception const& e)
-                    {
-                        fprintf(stderr, "Error cancelling upload job '%s': %s\n",
-                                job->upload_id().c_str(), e.what());
-                    }
-                });
-        }
-        else
-        {
-            ++it;
-        }
-    }
+
+    services_.erase(service_name);
+    watcher_.removeWatchedService(service_name);
+
+    const auto lower = make_pair(service_name, string());
+
+    for (auto it = downloads_.lower_bound(lower);
+         it != downloads_.cend() && it->first.first == service_name; )
+    {
+        auto job = it->second;
+        it = downloads_.erase(it);
+        cancel_job(job, "download " + job->download_id());
+    }
+
+    for (auto it = uploads_.lower_bound(lower);
+         it != uploads_.cend() && it->first.first == service_name; )
+    {
+        auto job = it->second;
+        it = uploads_.erase(it);
+        cancel_job(job, "upload " + job->upload_id());
+    }
+}
+
+template<typename Job>
+void PendingJobs::cancel_job(shared_ptr<Job> const& job, string const& identifier)
+{
+    auto f = job->p_->cancel(*job);
+    // This continuation also ensures that the job remains
+    // alive until the cancel method has completed.
+    auto cancel_future = std::make_shared<boost::future<void>>();
+    *cancel_future = f.then(
+        EXEC_IN_MAIN
+        [job, identifier, cancel_future](decltype(f) f) {
+            try
+            {
+                f.get();
+            }
+            catch (std::exception const& e)
+            {
+                fprintf(stderr, "Error cancelling job '%s': %s\n",
+                        identifier.c_str(), e.what());
+            }
+
+            // Break the reference cycle between the continuation
+            // future and closure, while making sure the future
+            // survives long enough to be marked ready.
+            auto fut = std::make_shared<boost::future<void>>(std::move(*cancel_future));
+            MainLoopExecutor::instance().submit([fut]{});
+        });
 }
 
 }
 
=== modified file 'src/provider/internal/ProviderInterface.cpp'
--- src/provider/internal/ProviderInterface.cpp	2016-07-21 12:48:40 +0000
+++ src/provider/internal/ProviderInterface.cpp	2016-09-09 02:13:43 +0000
@@ -18,6 +18,7 @@
 
 #include <unity/storage/provider/internal/ProviderInterface.h>
 #include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/Exceptions.h>
 #include <unity/storage/provider/ProviderBase.h>
 #include <unity/storage/provider/UploadJob.h>
 #include <unity/storage/provider/internal/AccountData.h>
@@ -171,15 +172,13 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
-                    job->p_->set_sender_bus_name(message.service().toStdString());
-
                     auto upload_id = QString::fromStdString(job->upload_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_write_socket();
                     file_desc.setFileDescriptor(fd);
                     close(fd);
 
-                    account->jobs().add_upload(std::move(job));
+                    account->jobs().add_upload(message.service(), std::move(job));
                     return message.createReply({
                             QVariant(upload_id),
                             QVariant::fromValue(file_desc),
@@ -198,15 +197,13 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
-                    job->p_->set_sender_bus_name(message.service().toStdString());
-
                     auto upload_id = QString::fromStdString(job->upload_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_write_socket();
                     file_desc.setFileDescriptor(fd);
                     close(fd);
 
-                    account->jobs().add_upload(std::move(job));
+                    account->jobs().add_upload(message.service(), std::move(job));
                     return message.createReply({
                             QVariant(upload_id),
                             QVariant::fromValue(file_desc),
@@ -219,15 +216,10 @@
 ProviderInterface::IMD ProviderInterface::FinishUpload(QString const& upload_id)
 {
     queue_request([upload_id](shared_ptr<AccountData> const& account, Context const& /*ctx*/, QDBusMessage const& message) {
-            // Throws if job is not available
-            auto job = account->jobs().get_upload(upload_id.toStdString());
-            if (job->p_->sender_bus_name() != message.service().toStdString())
-            {
-                throw runtime_error("Upload job belongs to a different client");
-            }
             // FIXME: removing the job at this point means we can't
             // cancel during finish().
-            account->jobs().remove_upload(upload_id.toStdString());
+            // Throws if job is not available
+            auto job = account->jobs().remove_upload(message.service(), upload_id.toStdString());
             auto f = job->p_->finish(*job);
             return f.then(
                 EXEC_IN_MAIN
@@ -243,12 +235,7 @@
 {
     queue_request([upload_id](shared_ptr<AccountData> const& account, Context const& /*ctx*/, QDBusMessage const& message) {
             // Throws if job is not available
-            auto job = account->jobs().get_upload(upload_id.toStdString());
-            if (job->p_->sender_bus_name() != message.service().toStdString())
-            {
-                throw runtime_error("Upload job belongs to a different client");
-            }
-            account->jobs().remove_upload(upload_id.toStdString());
+            auto job = account->jobs().remove_upload(message.service(), upload_id.toStdString());
             auto f = job->p_->cancel(*job);
             return f.then(
                 EXEC_IN_MAIN
@@ -268,15 +255,13 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
-                    job->p_->set_sender_bus_name(message.service().toStdString());
-
                     auto download_id = QString::fromStdString(job->download_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_read_socket();
                     file_desc.setFileDescriptor(fd);
                     close(fd);
 
-                    account->jobs().add_download(std::move(job));
+                    account->jobs().add_download(message.service(), std::move(job));
                     return message.createReply({
                             QVariant(download_id),
                             QVariant::fromValue(file_desc),
@@ -289,15 +274,10 @@
 void ProviderInterface::FinishDownload(QString const& download_id)
 {
     queue_request([download_id](shared_ptr<AccountData> const& account, Context const& /*ctx*/, QDBusMessage const& message) {
-            // Throws if job is not available
-            auto job = account->jobs().get_download(download_id.toStdString());
-            if (job->p_->sender_bus_name() != message.service().toStdString())
-            {
-                throw runtime_error("Download job belongs to a different client");
-            }
             // FIXME: removing the job at this point means we can't
             // cancel during finish().
-            account->jobs().remove_download(download_id.toStdString());
+            // Throws if job is not available
+            auto job = account->jobs().remove_download(message.service(), download_id.toStdString());
             auto f = job->p_->finish(*job);
             return f.then(
                 EXEC_IN_MAIN
 
=== modified file 'src/provider/internal/ServerImpl.cpp'
--- src/provider/internal/ServerImpl.cpp	2016-07-21 04:00:29 +0000
+++ src/provider/internal/ServerImpl.cpp	2016-09-09 02:13:43 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <unity/storage/provider/internal/ServerImpl.h>
+#include <unity/storage/provider/Exceptions.h>
 #include <unity/storage/provider/ProviderBase.h>
 #include <unity/storage/provider/internal/AccountData.h>
 #include <unity/storage/provider/internal/MainLoopExecutor.h>
@@ -37,7 +38,10 @@
 {
 
 ServerImpl::ServerImpl(ServerBase* server, string const& bus_name, string const& account_service_id)
-    : server_(server), bus_name_(bus_name), service_id_(account_service_id)
+    : server_(server)
+    , bus_name_(bus_name)
+    , service_id_(account_service_id)
+    , trace_message_handler_("storage_provider")
 {
     qDBusRegisterMetaType<Item>();
     qDBusRegisterMetaType<std::vector<Item>>();
@@ -85,7 +89,8 @@
 
     if (!bus.registerService(QString::fromStdString(bus_name_)))
     {
-        throw runtime_error("Could not acquire bus name: " + bus_name_);
+        string msg = string("Could not acquire bus name: ") + bus_name_ + ": " + bus.lastError().message().toStdString();
+        throw ResourceException(msg, int(bus.lastError().type()));
     }
     // TODO: claim bus name
     qDebug() << "Bus unique name:" << bus.baseService();
 
=== modified file 'src/provider/internal/TempfileUploadJobImpl.cpp'
--- src/provider/internal/TempfileUploadJobImpl.cpp	2016-07-12 02:22:05 +0000
+++ src/provider/internal/TempfileUploadJobImpl.cpp	2016-09-09 02:13:43 +0000
@@ -17,9 +17,10 @@
  */
 
 #include <unity/storage/provider/internal/TempfileUploadJobImpl.h>
+#include <unity/storage/provider/Exceptions.h>
 
 #include <cassert>
-#include <stdexcept>
+#include <exception>
 
 using namespace std;
 
@@ -64,6 +65,25 @@
     return tmpfile_->fileName().toStdString();
 }
 
+void TempfileUploadJobImpl::drain()
+{
+    while (true)
+    {
+        if (!tmpfile_->isOpen())
+        {
+            break;
+        }
+        if (!reader_->waitForReadyRead(0))
+        {
+            // Nothing was available to read: is the read channel still open?
+            if (tmpfile_->isOpen())
+            {
+                throw LogicException("Socket not closed");
+            }
+        }
+    }
+}
+
 void TempfileUploadJobImpl::on_ready_read()
 {
     char buffer[4096];
 
=== added file 'src/provider/internal/TestServerImpl.cpp'
--- src/provider/internal/TestServerImpl.cpp	1970-01-01 00:00:00 +0000
+++ src/provider/internal/TestServerImpl.cpp	2016-09-09 02:13:43 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+ */
+
+#include <unity/storage/provider/internal/TestServerImpl.h>
+#include <unity/storage/provider/Exceptions.h>
+#include <unity/storage/provider/ProviderBase.h>
+#include <unity/storage/provider/internal/AccountData.h>
+#include <unity/storage/provider/internal/DBusPeerCache.h>
+#include <unity/storage/provider/internal/ProviderInterface.h>
+#include <unity/storage/provider/internal/dbusmarshal.h>
+#include "provideradaptor.h"
+
+#include <OnlineAccounts/Account>
+
+#include <stdexcept>
+
+using namespace std;
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+namespace internal
+{
+
+TestServerImpl::TestServerImpl(unique_ptr<ProviderBase>&& provider,
+                               OnlineAccounts::Account* account,
+                               QDBusConnection const& connection,
+                               string const& object_path)
+    : connection_(connection), object_path_(object_path)
+{
+    qDBusRegisterMetaType<Item>();
+    qDBusRegisterMetaType<std::vector<Item>>();
+
+    auto peer_cache = make_shared<DBusPeerCache>(connection_);
+    auto account_data = make_shared<AccountData>(
+        move(provider), peer_cache, connection_, account);
+    interface_.reset(new ProviderInterface(account_data));
+    new ProviderAdaptor(interface_.get());
+
+    if (!connection_.registerObject(QString::fromStdString(object_path_),
+                                    interface_.get()))
+    {
+        string msg = "Could not register provider on connection: " + connection_.lastError().message().toStdString();
+        throw ResourceException(msg, int(connection_.lastError().type()));
+    }
+}
+
+TestServerImpl::~TestServerImpl()
+{
+    connection_.unregisterObject(QString::fromStdString(object_path_));
+}
+
+QDBusConnection const& TestServerImpl::connection() const
+{
+    return connection_;
+}
+
+string const& TestServerImpl::object_path() const
+{
+    return object_path_;
+}
+
+}
+}
+}
+}
 
=== modified file 'src/provider/internal/UploadJobImpl.cpp'
--- src/provider/internal/UploadJobImpl.cpp	2016-07-12 02:22:05 +0000
+++ src/provider/internal/UploadJobImpl.cpp	2016-09-09 02:13:43 +0000
@@ -17,7 +17,10 @@
  */
 
 #include <unity/storage/provider/internal/UploadJobImpl.h>
+#include <unity/storage/internal/safe_strerror.h>
+#include <unity/storage/provider/Exceptions.h>
 #include <unity/storage/provider/UploadJob.h>
+#include <unity/storage/provider/internal/MainLoopExecutor.h>
 
 #include <sys/socket.h>
 #include <sys/types.h>
@@ -26,6 +29,7 @@
 #include <stdexcept>
 
 using namespace std;
+using namespace unity::storage::internal;
 
 namespace unity
 {
@@ -42,18 +46,30 @@
     int socks[2];
     if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) < 0)
     {
-        throw runtime_error("could not create socketpair");
+        int error_code = errno;
+        string msg = "could not create socketpair: " + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
     read_socket_ = socks[0];
     write_socket_ = socks[1];
+
+#if 0
+    // TODO: We should be able to half-close the write channel of the read socket, and the read channel of
+    // the write socket. But, if we do, QLocalSocket indicates that everything was closed, which causes
+    // failures on the client side. We suspect a QLocalSocket bug -- need to investigate.
     if (shutdown(read_socket_, SHUT_WR) < 0)
     {
-        throw runtime_error("Could not shut down write channel on read socket");
+        int error_code = errno;
+        string msg = "could not shut down write channel on read socket: " + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
     if (shutdown(write_socket_, SHUT_RD) < 0)
     {
-        throw runtime_error("Could not shut down read channel on write socket");
+        int error_code = errno;
+        string msg = "Could not shut down read channel on write socket" + safe_strerror(error_code);
+        throw ResourceException(msg, error_code);
     }
+#endif
 }
 
 UploadJobImpl::~UploadJobImpl()
@@ -72,7 +88,7 @@
 {
 }
 
-std::string const& UploadJobImpl::upload_id() const
+string const& UploadJobImpl::upload_id() const
 {
     return upload_id_;
 }
@@ -90,28 +106,29 @@
     return sock;
 }
 
-string const& UploadJobImpl::sender_bus_name() const
-{
-    return sender_bus_name_;
-}
-
-void UploadJobImpl::set_sender_bus_name(string const& bus_name)
-{
-    assert(bus_name[0] == ':');
-    sender_bus_name_ = bus_name;
-}
-
-void UploadJobImpl::report_error(std::exception_ptr p)
+void UploadJobImpl::report_error(exception_ptr p)
 {
     if (read_socket_ >= 0)
     {
-        close(write_socket_);
+        close(read_socket_);
         read_socket_ = -1;
     }
 
     lock_guard<mutex> guard(completion_lock_);
     completed_ = true;
-    completion_promise_.set_exception(p);
+    // Convert std::exception_ptr to boost::exception_ptr
+    try
+    {
+        rethrow_exception(p);
+    }
+    catch (StorageException const& e)
+    {
+        completion_promise_.set_exception(e);
+    }
+    catch (...)
+    {
+        completion_promise_.set_exception(boost::current_exception());
+    }
 }
 
 boost::future<Item> UploadJobImpl::finish(UploadJob& job)
 
=== modified file 'src/provider/internal/dbusmarshal.cpp'
--- src/provider/internal/dbusmarshal.cpp	2016-07-21 12:48:40 +0000
+++ src/provider/internal/dbusmarshal.cpp	2016-09-09 02:13:43 +0000
@@ -31,29 +31,57 @@
 namespace provider
 {
 
+namespace
+{
+
+QDBusVariant to_qdbus_variant(MetadataValue const& v)
+{
+    switch (v.which())
+    {
+        case 0:
+            return QDBusVariant(QString::fromStdString(boost::get<string>(v)));
+        case 1:
+            return QDBusVariant(qlonglong(boost::get<int64_t>(v)));
+        default:
+            abort();  // Impossible.  // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace
+
 QDBusArgument& operator<<(QDBusArgument& argument, Item const& item)
 {
     argument.beginStructure();
     argument << QString::fromStdString(item.item_id);
-    argument << QString::fromStdString(item.parent_id);
+    {
+        argument.beginArray(qMetaTypeId<QString>());
+        for (auto const& id : item.parent_ids)
+        {
+            argument << QString::fromStdString(id);
+        }
+        argument.endArray();
+    }
     argument << QString::fromStdString(item.name);
     argument << QString::fromStdString(item.etag);
     argument << static_cast<int32_t>(item.type);
-    argument.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
-    for (auto const& pair : item.metadata)
     {
-        argument.beginMapEntry();
-        argument << QString::fromStdString(pair.first) << QDBusVariant(QString::fromStdString(pair.second));
-        argument.endMapEntry();
+        argument.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
+        for (auto const& pair : item.metadata)
+        {
+            argument.beginMapEntry();
+            argument << QString::fromStdString(pair.first) << to_qdbus_variant(pair.second);
+            argument.endMapEntry();
+        }
+        argument.endMap();
     }
-    argument.endMap();
     argument.endStructure();
     return argument;
 }
 
 QDBusArgument const& operator>>(QDBusArgument const&, Item&)
 {
-    throw std::runtime_error("Item decode not implemented");
+    // We don't expect to ever have to unmarshal anything, only marshal it.
+    qFatal("unexpected call to operator>>(QDBusArgument const&, Item&)");  // LCOV_EXCL_LINE
 }
 
 QDBusArgument& operator<<(QDBusArgument& argument, ItemList const& items)
@@ -69,7 +97,8 @@
 
 QDBusArgument const& operator>>(QDBusArgument const&, ItemList&)
 {
-    throw std::runtime_error("std::vector<Item> decode not implemented");
+    // We don't expect to ever have to unmarshal anything, only marshal it.
+    qFatal("unexpected call to operator>>(QDBusArgument const&, ItemList&)");  // LCOV_EXCL_LINE
 }
 
 }
 
=== added directory 'src/provider/testing'
=== added file 'src/provider/testing/TestServer.cpp'
--- src/provider/testing/TestServer.cpp	1970-01-01 00:00:00 +0000
+++ src/provider/testing/TestServer.cpp	2016-09-09 02:13:43 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+ */
+
+#include <unity/storage/provider/testing/TestServer.h>
+#include <unity/storage/provider/internal/TestServerImpl.h>
+#include <unity/storage/provider/ProviderBase.h>
+
+#include <OnlineAccounts/Account>
+
+using namespace std;
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+namespace testing
+{
+
+TestServer::TestServer(unique_ptr<ProviderBase>&& provider,
+                       OnlineAccounts::Account* account,
+                       QDBusConnection const& connection,
+                       string const& object_path)
+    : p_(new internal::TestServerImpl(move(provider), account,
+                                      connection, object_path))
+{
+}
+
+TestServer::~TestServer() = default;
+
+QDBusConnection const& TestServer::connection() const
+{
+    return p_->connection();
+}
+
+string const& TestServer::object_path() const
+{
+    return p_->object_path();
+}
+
+}
+}
+}
+}
 
=== modified file 'src/qt/client/Account.cpp'
--- src/qt/client/Account.cpp	2016-07-12 02:22:05 +0000
+++ src/qt/client/Account.cpp	2016-09-09 02:13:43 +0000
@@ -41,7 +41,7 @@
 
 Account::~Account() = default;
 
-Runtime* Account::runtime() const
+shared_ptr<Runtime> Account::runtime() const
 {
     return p_->runtime();
 }
 
=== modified file 'src/qt/client/CMakeLists.txt'
--- src/qt/client/CMakeLists.txt	2016-07-27 02:19:17 +0000
+++ src/qt/client/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -80,7 +80,7 @@
 # Build the remote client library
 set_source_files_properties(${CMAKE_SOURCE_DIR}/data/provider.xml PROPERTIES
     CLASSNAME ProviderInterface
-    INCLUDE unity/storage/qt/client/internal/remote_client/dbusmarshal.h
+    INCLUDE unity/storage/internal/dbusmarshal.h
 )
 
 qt5_add_dbus_interface(generated_files
@@ -109,6 +109,7 @@
     VERSION ${SF_CLIENT_LIBVERSION}
 )
 target_link_libraries(storage-framework-qt-client
+    storage-framework-common-internal
     Qt5::Concurrent
     Qt5::Core
     Qt5::DBus
 
=== modified file 'src/qt/client/Exceptions.cpp'
--- src/qt/client/Exceptions.cpp	2016-07-22 01:45:39 +0000
+++ src/qt/client/Exceptions.cpp	2016-09-09 02:13:43 +0000
@@ -42,6 +42,11 @@
     return what_string_.c_str();
 }
 
+QString StorageException::error_message() const
+{
+    return error_message_;
+}
+
 LocalCommsException::LocalCommsException(QString const& error_message)
     : StorageException("LocalCommsException", error_message)
 {
@@ -76,10 +81,9 @@
     throw *this;
 }
 
-DeletedException::DeletedException(QString const& error_message, QString const& identity, QString const& name)
+DeletedException::DeletedException(QString const& error_message, QString const& identity)
     : StorageException("DeletedException", error_message)
     , identity_(identity)
-    , name_(name)
 {
 }
 
@@ -100,13 +104,8 @@
     return identity_;
 }
 
-QString DeletedException::name() const
-{
-    return name_;
-}
-
 RuntimeDestroyedException::RuntimeDestroyedException(QString const& method)
-    : StorageException("RuntimeDestroyedException", method + ": Runtime was destroyed previously")
+    : StorageException("RuntimeDestroyedException", method + ": runtime was destroyed previously")
 {
 }
 
@@ -276,8 +275,9 @@
     throw *this;
 }
 
-ResourceException::ResourceException(QString const& error_message)
+ResourceException::ResourceException(QString const& error_message, int error_code)
     : StorageException("ResourceException", error_message)
+    , error_code_(error_code)
 {
 }
 
@@ -293,6 +293,11 @@
     throw *this;
 }
 
+int ResourceException::error_code() const noexcept
+{
+    return error_code_;
+}
+
 }  // namespace client
 }  // namespace qt
 }  // namespace storage
 
=== modified file 'src/qt/client/Item.cpp'
--- src/qt/client/Item.cpp	2016-07-14 00:25:40 +0000
+++ src/qt/client/Item.cpp	2016-09-09 02:13:43 +0000
@@ -51,7 +51,7 @@
     return p_->name();
 }
 
-Root* Item::root() const
+shared_ptr<Root> Item::root() const
 {
     return p_->root();
 }
 
=== modified file 'src/qt/client/Root.cpp'
--- src/qt/client/Root.cpp	2016-07-12 02:22:05 +0000
+++ src/qt/client/Root.cpp	2016-09-09 02:13:43 +0000
@@ -30,6 +30,7 @@
 {
 
 using namespace internal;
+using namespace std;
 
 Root::Root(RootBase* p)
     : Folder(p)
@@ -38,7 +39,7 @@
 
 Root::~Root() = default;
 
-Account* Root::account() const
+shared_ptr<Account> Root::account() const
 {
     return dynamic_cast<RootBase*>(p_.get())->account();
 }
 
=== modified file 'src/qt/client/Runtime.cpp'
--- src/qt/client/Runtime.cpp	2016-07-21 04:00:29 +0000
+++ src/qt/client/Runtime.cpp	2016-09-09 02:13:43 +0000
@@ -64,6 +64,12 @@
     return p_->accounts();
 }
 
+shared_ptr<Account> Runtime::make_test_account(QString const& bus_name,
+                                               QString const& object_path)
+{
+    return p_->make_test_account(bus_name, object_path);
+}
+
 }  // namespace client
 }  // namespace qt
 }  // namespace storage
 
=== modified file 'src/qt/client/Uploader.cpp'
--- src/qt/client/Uploader.cpp	2016-07-12 02:22:05 +0000
+++ src/qt/client/Uploader.cpp	2016-09-09 02:13:43 +0000
@@ -46,6 +46,11 @@
     return p_->socket();
 }
 
+int64_t Uploader::size() const
+{
+    return p_->size();
+}
+
 QFuture<shared_ptr<File>> Uploader::finish_upload()
 {
     return p_->finish_upload();
 
=== modified file 'src/qt/client/internal/AccountBase.cpp'
--- src/qt/client/internal/AccountBase.cpp	2016-07-14 04:50:36 +0000
+++ src/qt/client/internal/AccountBase.cpp	2016-09-09 02:13:43 +0000
@@ -19,6 +19,8 @@
 #include <unity/storage/qt/client/internal/AccountBase.h>
 
 #include <unity/storage/qt/client/Exceptions.h>
+#include <unity/storage/qt/client/internal/RuntimeBase.h>
+#include <unity/storage/qt/client/Runtime.h>
 
 #include <cassert>
 
@@ -42,13 +44,18 @@
     assert(runtime.lock());
 }
 
-Runtime* AccountBase::runtime() const
+shared_ptr<Runtime> AccountBase::runtime() const
 {
     if (auto runtime = runtime_.lock())
     {
-        return runtime.get();
+        auto runtime_base = runtime->p_;
+        if (runtime_base->destroyed_)
+        {
+            throw RuntimeDestroyedException("Account::runtime()");
+        }
+        return runtime;
     }
-    throw RuntimeDestroyedException("AccountBase::runtime()");
+    throw RuntimeDestroyedException("Account::runtime()");
 }
 
 void AccountBase::set_public_instance(weak_ptr<Account> const& p)
 
=== modified file 'src/qt/client/internal/ItemBase.cpp'
--- src/qt/client/internal/ItemBase.cpp	2016-07-14 04:50:36 +0000
+++ src/qt/client/internal/ItemBase.cpp	2016-09-09 02:13:43 +0000
@@ -18,7 +18,9 @@
 
 #include <unity/storage/qt/client/internal/ItemBase.h>
 
+#include <unity/storage/qt/client/Account.h>
 #include <unity/storage/qt/client/Exceptions.h>
+#include <unity/storage/qt/client/Root.h>
 
 #include <cassert>
 
@@ -46,21 +48,24 @@
 
 QString ItemBase::native_identity() const
 {
+    throw_if_destroyed("Item::native_identity()");
     return identity_;
 }
 
 ItemType ItemBase::type() const
 {
+    throw_if_destroyed("Item::type()");
     return type_;
 }
 
-Root* ItemBase::root() const
+shared_ptr<Root> ItemBase::root() const
 {
-    if (auto r = root_.lock())
+    auto root = get_root();
+    if (!root)
     {
-        return r.get();
+        throw RuntimeDestroyedException("Item::root()");
     }
-    throw RuntimeDestroyedException("Item::root()");
+    return root;
 }
 
 void ItemBase::set_root(std::weak_ptr<Root> root)
@@ -75,6 +80,36 @@
     public_instance_ = p;
 }
 
+shared_ptr<Root> ItemBase::get_root() const noexcept
+{
+    try
+    {
+        auto root = root_.lock();
+        if (root)
+        {
+            root->account();  // Throws if either account or runtime has been destroyed.
+            return root;
+        }
+    }
+    catch (RuntimeDestroyedException const&)
+    {
+    }
+    return nullptr;
+}
+
+void ItemBase::throw_if_destroyed(QString const& method) const
+{
+    if (deleted_)
+    {
+        QString msg = method + ": \"" + identity_ + "\" was deleted previously";
+        throw DeletedException(msg, identity_);
+    }
+    if (!get_root())
+    {
+        throw RuntimeDestroyedException(method);
+    }
+}
+
 }  // namespace internal
 }  // namespace client
 }  // namespace qt
 
=== modified file 'src/qt/client/internal/RootBase.cpp'
--- src/qt/client/internal/RootBase.cpp	2016-07-27 02:19:17 +0000
+++ src/qt/client/internal/RootBase.cpp	2016-09-09 02:13:43 +0000
@@ -18,6 +18,7 @@
 
 #include <unity/storage/qt/client/internal/RootBase.h>
 
+#include <unity/storage/qt/client/Account.h>
 #include <unity/storage/qt/client/Exceptions.h>
 
 #include <cassert>
@@ -43,11 +44,19 @@
     assert(account.lock());
 }
 
-Account* RootBase::account() const
+shared_ptr<Account> RootBase::account() const
 {
     if (auto acc = account_.lock())
     {
-        return acc.get();
+        try
+        {
+            acc->runtime();
+        }
+        catch (RuntimeDestroyedException const&)
+        {
+            throw RuntimeDestroyedException("Root::account()");
+        }
+        return acc;
     }
     throw RuntimeDestroyedException("Root::account()");
 }
 
=== modified file 'src/qt/client/internal/RuntimeBase.cpp'
--- src/qt/client/internal/RuntimeBase.cpp	2016-07-12 02:22:05 +0000
+++ src/qt/client/internal/RuntimeBase.cpp	2016-09-09 02:13:43 +0000
@@ -34,11 +34,6 @@
 namespace internal
 {
 
-RuntimeBase::RuntimeBase()
-    : destroyed_(false)
-{
-}
-
 void RuntimeBase::set_public_instance(weak_ptr<Runtime> p)
 {
     assert(p.lock());
 
=== modified file 'src/qt/client/internal/UploaderBase.cpp'
--- src/qt/client/internal/UploaderBase.cpp	2016-07-22 01:45:39 +0000
+++ src/qt/client/internal/UploaderBase.cpp	2016-09-09 02:13:43 +0000
@@ -25,6 +25,8 @@
 #include <QFuture>
 #pragma GCC diagnostic pop
 
+#include <cassert>
+
 using namespace std;
 
 namespace unity
@@ -38,9 +40,16 @@
 namespace internal
 {
 
-UploaderBase::UploaderBase(ConflictPolicy policy)
+UploaderBase::UploaderBase(ConflictPolicy policy, int64_t size)
     : policy_(policy)
-{
+    , size_(size)
+{
+    assert(size >= 0);
+}
+
+int64_t UploaderBase::size() const
+{
+    return size_;
 }
 
 }  // namespace internal
 
=== modified file 'src/qt/client/internal/local_client/AccountImpl.cpp'
--- src/qt/client/internal/local_client/AccountImpl.cpp	2016-07-14 04:50:36 +0000
+++ src/qt/client/internal/local_client/AccountImpl.cpp	2016-09-09 02:13:43 +0000
@@ -67,7 +67,7 @@
     if (ec)
     {
         QString msg = "Account::roots(): Cannot stat " + QString(dir) + ": " + QString::fromStdString(ec.message());
-        throw ResourceException(msg);
+        throw ResourceException(msg, errno);
     }
     if (!is_dir)
     {
@@ -85,7 +85,7 @@
         {
             QString msg = "Account::roots(): Cannot create " + QString(dir) + ": "
                           + QString::fromStdString(ec.message());
-            throw ResourceException(msg);
+            throw ResourceException(msg, ec.value());
         }
     }
     return data_dir;
@@ -109,22 +109,32 @@
 
 QString AccountImpl::owner() const
 {
+    runtime();  // Throws RuntimeDestroyedException if runtime was destroyed.
     return owner_;
 }
 
 QString AccountImpl::owner_id() const
 {
+    runtime();  // Throws RuntimeDestroyedException if runtime was destroyed.
     return owner_id_;
 }
 
 QString AccountImpl::description() const
 {
+    runtime();  // Throws RuntimeDestroyedException if runtime was destroyed.
     return description_;
 }
 
 QFuture<QVector<Root::SPtr>> AccountImpl::roots()
 {
-    using namespace boost::filesystem;
+    try
+    {
+        runtime();  // Throws RuntimeDestroyedException if runtime was destroyed.
+    }
+    catch (RuntimeDestroyedException const& e)
+    {
+        return make_exceptional_future<QVector<Root::SPtr>>(e);
+    }
 
     if (!roots_.isEmpty())
     {
@@ -132,6 +142,9 @@
     }
 
     // Create the root on first access.
+
+    using namespace boost::filesystem;
+
     auto rpath = canonical(get_data_dir()).native();
     auto root = RootImpl::make_root(QString::fromStdString(rpath), public_instance_);
     roots_.append(root);
 
=== modified file 'src/qt/client/internal/local_client/CMakeLists.txt'
--- src/qt/client/internal/local_client/CMakeLists.txt	2016-07-22 00:17:24 +0000
+++ src/qt/client/internal/local_client/CMakeLists.txt	2016-09-09 02:13:43 +0000
@@ -7,6 +7,7 @@
         ${CMAKE_CURRENT_SOURCE_DIR}/RootImpl.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Runtime_create.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/RuntimeImpl.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/storage_exception.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/UploaderImpl.cpp
         ${CMAKE_SOURCE_DIR}/include/unity/storage/qt/client/internal/local_client/DownloaderImpl.h
         ${CMAKE_SOURCE_DIR}/include/unity/storage/qt/client/internal/local_client/UploaderImpl.h
 
=== modified file 'src/qt/client/internal/local_client/DownloaderImpl.cpp'
--- src/qt/client/internal/local_client/DownloaderImpl.cpp	2016-07-22 00:17:24 +0000
+++ src/qt/client/internal/local_client/DownloaderImpl.cpp	2016-09-09 02:13:43 +0000
@@ -23,7 +23,10 @@
 #include <unity/storage/qt/client/File.h>
 #include <unity/storage/qt/client/internal/make_future.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
 #include <QLocalSocket>
+#pragma GCC diagnostic pop
 
 #include <cassert>
 
@@ -79,8 +82,10 @@
     input_file_.reset(new QFile(filename_));
     if (!input_file_->open(QIODevice::ReadOnly))
     {
-        handle_error("cannot open " + filename_ + ": " + input_file_->errorString());
+        // LCOV_EXCL_START
+        handle_error("cannot open " + filename_ + ": " + input_file_->errorString(), input_file_->error());
         return;
+        // LCOV_EXCL_STOP
     }
     bytes_to_write_ = input_file_->size();
 
@@ -116,7 +121,7 @@
                               + QString::number(written) + " byte";
                 msg += written == 1 ? " was" : "s were";
                 msg += " consumed.";
-                make_exceptional_future(qf_, LogicException(msg));
+                qf_.reportException(LogicException(msg));
             }
             else
             {
@@ -131,12 +136,12 @@
         case cancelled:
         {
             QString msg = "Downloader::finish_download(): download of " + filename_ + " was cancelled";
-            make_exceptional_future(qf_, CancelledException(msg));
+            qf_.reportException(CancelledException(msg));
             break;
         }
         case error:
         {
-            make_exceptional_future(qf_, ResourceException(error_msg_));
+            qf_.reportException(ResourceException(error_msg_, error_code_));
             break;
         }
         default:
@@ -144,7 +149,7 @@
             abort();  // LCOV_EXCL_LINE  // Impossible
         }
     }
-    make_ready_future(qf_);
+    qf_.reportFinished();
     QThread::currentThread()->quit();
 }
 
@@ -189,7 +194,8 @@
 
 void DownloadWorker::on_error()
 {
-    handle_error(write_socket_->errorString());
+    disconnect(write_socket_.get(), nullptr, this, nullptr);
+    handle_error(write_socket_->errorString(), write_socket_->error());
 }
 
 // Read the next chunk of data from the input file and write it to the socket.
@@ -203,25 +209,31 @@
     auto bytes_read = input_file_->read(buf.data(), buf.size());
     if (bytes_read == -1)
     {
-        handle_error(filename_ + ": read error: " + input_file_->errorString());
+        // LCOV_EXCL_START
+        handle_error(filename_ + ": read error: " + input_file_->errorString(), input_file_->error());
         return;
+        // LCOV_EXCL_STOP
     }
     buf.resize(bytes_read);
 
     auto bytes_written = write_socket_->write(buf);
     if (bytes_written == -1)
     {
-        handle_error(filename_ + ": socket error: " + write_socket_->errorString());
+        // LCOV_EXCL_START
+        handle_error(filename_ + ": socket error: " + write_socket_->errorString(), write_socket_->error());
+        // LCOV_EXCL_STOP
     }
     else if (bytes_written != bytes_read)
     {
+        // LCOV_EXCL_START
         QString msg = filename_ + ": write error, requested " + bytes_read + " B, but wrote only "
                       + bytes_written + " B.";
-        handle_error(msg);
+        handle_error(msg, 0);
+        // LCOV_EXCL_STOP
     }
 }
 
-void DownloadWorker::handle_error(QString const& msg)
+void DownloadWorker::handle_error(QString const& msg, int error_code)
 {
     if (state_ == in_progress)
     {
@@ -229,6 +241,7 @@
     }
     state_ = error;
     error_msg_ = "Downloader: " + msg;
+    error_code_ = error_code;
     do_finish();
 }
 
@@ -245,17 +258,18 @@
 
 DownloaderImpl::DownloaderImpl(weak_ptr<File> file)
     : DownloaderBase(file)
-    , read_socket_(new QLocalSocket)
+    , read_socket_(new QLocalSocket, [](QLocalSocket* s){ s->deleteLater(); })
 {
     // Set up socket pair.
     int fds[2];
-    int rc = socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, fds);
+    int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
     if (rc == -1)
     {
         // LCOV_EXCL_START
         QString msg = "Downloader: cannot create socket pair: "
                       + QString::fromStdString(storage::internal::safe_strerror(errno));
-        make_exceptional_future(qf_, ResourceException(msg));
+        qf_.reportException(ResourceException(msg, errno));
+        qf_.reportFinished();
         return;
         // LCOV_EXCL_STOP
     }
 
=== modified file 'src/qt/client/internal/local_client/FileImpl.cpp'
--- src/qt/client/internal/local_client/FileImpl.cpp	2016-07-22 01:45:39 +0000
+++ src/qt/client/internal/local_client/FileImpl.cpp	2016-09-09 02:13:43 +0000
@@ -22,6 +22,7 @@
 #include <unity/storage/qt/client/Exceptions.h>
 #include <unity/storage/qt/client/File.h>
 #include <unity/storage/qt/client/internal/local_client/DownloaderImpl.h>
+#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
 #include <unity/storage/qt/client/internal/local_client/UploaderImpl.h>
 #include <unity/storage/qt/client/internal/make_future.h>
 #include <unity/storage/qt/client/Uploader.h>
@@ -50,47 +51,44 @@
 
 QString FileImpl::name() const
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        throw deleted_ex("File::name()");
-    }
+    throw_if_destroyed("File::name()");
     return name_;
 }
 
 int64_t FileImpl::size() const
 {
-    lock_guard<mutex> guard(mutex_);
-
-    if (deleted_)
-    {
-        throw deleted_ex("File::size()");
-    }
-
+    lock_guard<decltype(mutex_)> guard(mutex_);
+
+    throw_if_destroyed("File::size()");
     try
     {
         boost::filesystem::path p = identity_.toStdString();
         return file_size(p);
     }
-    catch (std::exception const& e)
+    catch (std::exception const&)
     {
-        throw ResourceException(e.what());
+        throw_storage_exception(QString("File::size()"), current_exception());
     }
 }
 
 QFuture<Uploader::SPtr> FileImpl::create_uploader(ConflictPolicy policy, int64_t size)
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        return make_exceptional_future<Uploader::SPtr>(deleted_ex("File::create_uploader()"));
+    try
+    {
+        throw_if_destroyed("File::create_uploader()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<Uploader::SPtr>(e);
     }
     if (size < 0)
     {
         QString msg = "File::create_uploader(): size must be >= 0";
-        return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+        return internal::make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
     }
 
     auto file = dynamic_pointer_cast<File>(public_instance_.lock());
@@ -102,11 +100,15 @@
 
 QFuture<Downloader::SPtr> FileImpl::create_downloader()
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        return make_exceptional_future<Downloader::SPtr>(deleted_ex("File::create_downloader()"));
+    try
+    {
+        throw_if_destroyed("File::create_downloader()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<Downloader::SPtr>(e);
     }
 
     auto pi = public_instance_.lock();
 
=== modified file 'src/qt/client/internal/local_client/FolderImpl.cpp'
--- src/qt/client/internal/local_client/FolderImpl.cpp	2016-07-22 01:45:39 +0000
+++ src/qt/client/internal/local_client/FolderImpl.cpp	2016-09-09 02:13:43 +0000
@@ -24,7 +24,8 @@
 #include <unity/storage/qt/client/Uploader.h>
 #include <unity/storage/qt/client/internal/make_future.h>
 #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
-#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
+#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
+#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
 #include <unity/storage/qt/client/internal/local_client/UploaderImpl.h>
 
 #include <boost/algorithm/string/predicate.hpp>
@@ -62,22 +63,36 @@
 {
 }
 
+QString FolderImpl::name() const
+{
+    lock_guard<decltype(mutex_)> guard(mutex_);
+
+    throw_if_destroyed("Item::name()");
+    return name_;
+}
+
 QFuture<QVector<Item::SPtr>> FolderImpl::list() const
 {
+    try
+    {
+        throw_if_destroyed("Folder::list()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<QVector<Item::SPtr>>(e);
+    }
+
     auto This = dynamic_pointer_cast<FolderImpl const>(shared_from_this());  // Keep this folder alive while the lambda is alive.
     auto list = [This]()
     {
-        lock_guard<mutex> guard(This->mutex_);
-
-        if (This->deleted_)
-        {
-            throw This->deleted_ex("Folder::list()");
-        }
-
+        lock_guard<decltype(mutex_)> guard(This->mutex_);
+
+        This->throw_if_destroyed("Folder::list()");
         try
         {
             using namespace boost::filesystem;
 
+            auto root = This->root_.lock();
             QVector<Item::SPtr> results;
             for (directory_iterator it(This->native_identity().toStdString()); it != directory_iterator(); ++it)
             {
@@ -90,11 +105,11 @@
                 QString path = QString::fromStdString(dirent.path().native());
                 if (is_directory(s))
                 {
-                    results.append(make_folder(path, This->root_));
+                    results.append(make_folder(path, root));
                 }
                 else if (is_regular_file(s))
                 {
-                    results.append(FileImpl::make_file(path, This->root_));
+                    results.append(FileImpl::make_file(path, root));
                 }
                 else
                 {
@@ -103,9 +118,9 @@
             }
             return results;
         }
-        catch (std::exception const& e)
+        catch (std::exception const&)
         {
-            throw ResourceException(QString("Folder::list(): ") + e.what());
+            throw_storage_exception("Folder::list()", current_exception());
         }
     };
     return QtConcurrent::run(list);
@@ -113,49 +128,51 @@
 
 QFuture<QVector<Item::SPtr>> FolderImpl::lookup(QString const& name) const
 {
+    try
+    {
+        throw_if_destroyed("Folder::lookup()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<QVector<Item::SPtr>>(e);
+    }
+
     auto This = dynamic_pointer_cast<FolderImpl const>(shared_from_this());  // Keep this folder alive while the lambda is alive.
     auto lookup = [This, name]() -> QVector<Item::SPtr>
     {
-        lock_guard<mutex> guard(This->mutex_);
-
-        if (This->deleted_)
-        {
-            throw This->deleted_ex("Folder::lookup()");
-        }
-
+        lock_guard<decltype(mutex_)> guard(This->mutex_);
+
+        This->throw_if_destroyed("Folder::lookup()");  // LCOV_EXCL_LINE
         try
         {
             using namespace boost::filesystem;
 
+            auto root = This->root_.lock();
             path p = This->native_identity().toStdString();
             auto sanitized_name = sanitize(name, "Folder::lookup()");
             if (is_reserved_path(sanitized_name))
             {
-                throw NotExistsException("Folder::lookup(): no such item: " + name, name);
+                throw NotExistsException("Folder::lookup(): no such item: \"" + name + "\"", name);
             }
             p /= sanitized_name;
             file_status s = status(p);
             if (is_directory(s))
             {
                 QVector<Item::SPtr> v;
-                v.append(make_folder(QString::fromStdString(p.native()), This->root_));
+                v.append(make_folder(QString::fromStdString(p.native()), root));
                 return v;
             }
             if (is_regular_file(s))
             {
                 QVector<Item::SPtr> v;
-                v.append(FileImpl::make_file(QString::fromStdString(p.native()), This->root_));
+                v.append(FileImpl::make_file(QString::fromStdString(p.native()), root));
                 return v;
             }
-            throw NotExistsException("Folder::lookup(): no such item: " + name, name);
-        }
-        catch (StorageException const&)
-        {
-            throw;
-        }
-        catch (std::exception const& e)
-        {
-            throw ResourceException(QString("Folder::lookup(): ") + e.what());
+            throw NotExistsException("Folder::lookup(): no such item: \"" + name + "\"", name);
+        }
+        catch (std::exception const&)
+        {
+            throw_storage_exception("Folder::lookup()", current_exception());
         }
     };
     return QtConcurrent::run(lookup);
@@ -163,12 +180,15 @@
 
 QFuture<Folder::SPtr> FolderImpl::create_folder(QString const& name)
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    QFutureInterface<Folder::SPtr> qf;
-    if (deleted_)
-    {
-        return make_exceptional_future<Folder::SPtr>(deleted_ex("Folder::create_folder()"));
+    try
+    {
+        throw_if_destroyed("Folder::create_folder()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<Folder::SPtr>(e);
     }
 
     try
@@ -179,31 +199,40 @@
         auto sanitized_name = sanitize(name, "Folder::create_folder()");
         if (is_reserved_path(sanitized_name))
         {
-            QString msg = "Folder::create_folder(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
-            return make_exceptional_future<Folder::SPtr>(InvalidArgumentException(msg));
+            QString msg = "Folder::create_folder(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
+            throw InvalidArgumentException(msg);
         }
         p /= sanitized_name;
+        if (exists(p))
+        {
+            QString msg = "Folder::create_folder(): item with name \"" + name + "\" exists already";
+            throw ExistsException(msg, native_identity() + "/" + name, name);
+        }
         create_directory(p);
         return make_ready_future(make_folder(QString::fromStdString(p.native()), root_));
     }
-    catch (std::exception const& e)
+    catch (std::exception const&)
     {
-        return make_exceptional_future<Folder::SPtr>(ResourceException(QString("Folder::create_folder: ") + e.what()));
+        return make_exceptional_future<Folder::SPtr>("Folder::create_folder()", current_exception());
     }
 }
 
 QFuture<shared_ptr<Uploader>> FolderImpl::create_file(QString const& name, int64_t size)
 {
-    unique_lock<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        return make_exceptional_future<Uploader::SPtr>(deleted_ex("Folder::create_file()"));
+    try
+    {
+        throw_if_destroyed("Folder::create_file()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<shared_ptr<Uploader>>(e);
     }
     if (size < 0)
     {
         QString msg = "Folder::create_file(): size must be >= 0";
-        return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+        return internal::make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
     }
 
     try
@@ -214,14 +243,14 @@
         auto sanitized_name = sanitize(name, "Folder::create_file()");
         if (is_reserved_path(sanitized_name))
         {
-            QString msg = "Folder::create_file(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
-            return make_exceptional_future<Uploader::SPtr>(InvalidArgumentException(msg));
+            QString msg = "Folder::create_file(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
+            throw InvalidArgumentException(msg);
         }
         p /= sanitized_name;
         if (exists(p))
         {
             QString msg = "Folder::create_file(): item with name \"" + name + "\" exists already";
-            return make_exceptional_future<Uploader::SPtr>(ExistsException(msg, native_identity(), name));
+            throw ExistsException(msg, native_identity() + "/" + name, name);
         }
         auto impl = new UploaderImpl(shared_ptr<File>(),
                                      size,
@@ -231,9 +260,9 @@
         Uploader::SPtr uploader(new Uploader(impl));
         return make_ready_future(uploader);
     }
-    catch (std::exception const& e)
+    catch (std::exception const&)
     {
-        return make_exceptional_future<Uploader::SPtr>(ResourceException(QString("Folder::create_file: ") + e.what()));
+        return make_exceptional_future<Uploader::SPtr>("Folder::create_file()", current_exception());
     }
 }
 
 
=== modified file 'src/qt/client/internal/local_client/ItemImpl.cpp'
--- src/qt/client/internal/local_client/ItemImpl.cpp	2016-07-22 00:17:24 +0000
+++ src/qt/client/internal/local_client/ItemImpl.cpp	2016-09-09 02:13:43 +0000
@@ -21,14 +21,16 @@
 #include <unity/storage/internal/safe_strerror.h>
 #include <unity/storage/qt/client/Account.h>
 #include <unity/storage/qt/client/Exceptions.h>
-#include <unity/storage/qt/client/internal/make_future.h>
 #include <unity/storage/qt/client/internal/local_client/AccountImpl.h>
 #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
 #include <unity/storage/qt/client/internal/local_client/RootImpl.h>
-#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
+#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
+#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
+#include <unity/storage/qt/client/internal/make_future.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
 #include <QtConcurrent>
 #pragma GCC diagnostic pop
@@ -54,7 +56,6 @@
 
 ItemImpl::ItemImpl(QString const& identity, ItemType type)
     : ItemBase(identity, type)
-    , deleted_(false)
 {
     assert(!identity.isEmpty());
     auto path = boost::filesystem::canonical(identity.toStdString());
@@ -64,102 +65,70 @@
 
 ItemImpl::~ItemImpl() = default;
 
-QString ItemImpl::name() const
-{
-    lock_guard<mutex> guard(mutex_);
-
-    if (deleted_)
-    {
-        throw deleted_ex("Item::name()");
-    }
-    return name_;
-}
-
 QString ItemImpl::etag() const
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        throw deleted_ex("Item::etag()");
-    }
+    throw_if_destroyed("Item::etag()");
     return etag_;
 }
 
 QVariantMap ItemImpl::metadata() const
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        throw deleted_ex("Item::metadata()");
-    }
+    throw_if_destroyed("Item::metadata()");
     return metadata_;
 }
 
 QDateTime ItemImpl::last_modified_time() const
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    if (deleted_)
-    {
-        throw deleted_ex("Item::last_modified_time()");
-    }
+    throw_if_destroyed("Item::last_modified_time()");
     return modified_time_;
 }
 
-namespace
-{
-
-using namespace boost::filesystem;
-
-void copy_recursively(path const& source, path const& target)
-{
-    auto s = status(source);
-    if (is_regular_file(s))
-    {
-        copy_file(source, target);
-        return;
-    }
-    else if (is_directory(s))
-    {
-        copy_directory(source, target);  // Poorly named in boost; this creates the target dir without recursion
-        for (directory_iterator it(source); it != directory_iterator(); ++it)
-        {
-            path source_entry = it->path();
-            path target_entry = target;
-            target_entry /= source_entry.filename();
-            copy_recursively(source_entry, target_entry);
-        }
-    }
-    else
-    {
-        // Ignore everything that's not a directory or file.
-    }
-}
-
-}  // namespace
-
 QFuture<shared_ptr<Item>> ItemImpl::copy(shared_ptr<Folder> const& new_parent, QString const& new_name)
 {
+    if (!new_parent)
+    {
+        QString msg = "Item::copy(): new_parent cannot be nullptr";
+        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
+    }
+    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
+
+    lock(mutex_, new_parent_impl->mutex_);
+    lock_guard<decltype(mutex_)> this_guard(mutex_, std::adopt_lock);
+    lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
+
+    try
+    {
+        throw_if_destroyed("Item::copy()");
+        new_parent_impl->throw_if_destroyed("Item::copy()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<shared_ptr<Item>>(e);
+    }
+
     auto This = dynamic_pointer_cast<ItemImpl>(shared_from_this());  // Keep this item alive while the lambda is alive.
     auto copy = [This, new_parent, new_name]() -> Item::SPtr
     {
         auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
 
         lock(This->mutex_, new_parent_impl->mutex_);
-        lock_guard<mutex> this_guard(This->mutex_, std::adopt_lock);
-        lock_guard<mutex> other_guard(new_parent_impl->mutex_, adopt_lock);
-
-        if (This->deleted_ || new_parent_impl->deleted_)
-        {
-            throw This->deleted_ex("Item::copy");
-        }
-
-        if (This->root()->account() != new_parent->root()->account())
+        lock_guard<decltype(mutex_)> this_guard(This->mutex_, std::adopt_lock);
+        lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
+
+        This->throw_if_destroyed("Item::copy()");
+        new_parent_impl->throw_if_destroyed("Item::copy()");
+
+        // TODO: This needs to deeply compare account identity because the client may have refreshed the accounts list.
+        if (This->root()->account() != new_parent->root()->account())  // Throws if account or runtime were destroyed.
         {
             // Can't do cross-account copy.
-            QString msg = QString("Item::copy(): Source (") + This->name_ + ") and target ("
+            QString msg = QString("Item::copy(): source (") + This->name_ + ") and target ("
                           + new_name + ") must belong to the same account";
             throw LogicException(msg);
         }
@@ -175,22 +144,22 @@
             target_path /= sanitized_name;
             if (is_reserved_path(target_path))
             {
-                QString msg = "Item::copy(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
+                QString msg = "Item::copy(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
                 throw InvalidArgumentException(msg);
             }
 
+            if (exists(target_path))
+            {
+                QString msg = "Item::copy(): item with name \"" + new_name + "\" exists already";
+                throw ExistsException(msg, This->identity_, This->name_);
+            }
+
             if (This->type_ == ItemType::file)
             {
                 copy_file(source_path, target_path);
                 return FileImpl::make_file(QString::fromStdString(target_path.native()), new_parent_impl->root_);
             }
 
-            if (exists(target_path))
-            {
-                QString msg = "Item::copy(): item with name \"" + new_name + "\" exists already";
-                throw ExistsException(msg, This->identity_, This->name_);
-            }
-
             // For recursive copy, we create a temporary directory in lieu of target_path and recursively copy
             // everything into the temporary directory. This ensures that we don't invalidate directory iterators
             // by creating things while we are iterating, potentially getting trapped in an infinite loop.
@@ -199,7 +168,7 @@
             create_directories(tmp_path);
             for (directory_iterator it(source_path); it != directory_iterator(); ++it)
             {
-                if (tmp_path.compare(canonical(it->path())) == 0)
+                if (is_reserved_path(it->path()))
                 {
                     continue;  // Don't recurse into the temporary directory
                 }
@@ -209,15 +178,15 @@
                     path source_entry = it->path();
                     path target_entry = tmp_path;
                     target_entry /= source_entry.filename();
-                    copy_recursively(source_entry, target_entry);
+                    ItemImpl::copy_recursively(source_entry, target_entry);
                 }
             }
             rename(tmp_path, target_path);
             return FolderImpl::make_folder(QString::fromStdString(target_path.native()), new_parent_impl->root_);
         }
-        catch (std::exception const& e)
+        catch (std::exception const&)
         {
-            throw ResourceException(QString("Item::copy(): ") + e.what());
+            throw_storage_exception("Item::copy()", current_exception());
         }
     };
     return QtConcurrent::run(copy);
@@ -225,31 +194,51 @@
 
 QFuture<shared_ptr<Item>> ItemImpl::move(shared_ptr<Folder> const& new_parent, QString const& new_name)
 {
+    if (!new_parent)
+    {
+        QString msg = "Item::move(): new_parent cannot be nullptr";
+        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
+    }
+    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
+
+    lock(mutex_, new_parent_impl->mutex_);
+    lock_guard<decltype(mutex_)> this_guard(mutex_, std::adopt_lock);
+    lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
+
+    try
+    {
+        throw_if_destroyed("Item::move()");
+        new_parent_impl->throw_if_destroyed("Item::move()");
+    }
+    catch (StorageException const& e)
+    {
+        return internal::make_exceptional_future<shared_ptr<Item>>(e);
+    }
+
     auto This = dynamic_pointer_cast<ItemImpl>(shared_from_this());  // Keep this item alive while the lambda is alive.
     auto move = [This, new_parent, new_name]() -> Item::SPtr
     {
         auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
 
         lock(This->mutex_, new_parent_impl->mutex_);
-        lock_guard<mutex> this_guard(This->mutex_, std::adopt_lock);
-        lock_guard<mutex> other_guard(new_parent_impl->mutex_, adopt_lock);
-
-        if (This->deleted_ || new_parent_impl->deleted_)
-        {
-            throw This->deleted_ex("Item::move");
-        }
-
-        if (This->root()->account() != new_parent->root()->account())
+        lock_guard<decltype(mutex_)> this_guard(This->mutex_, std::adopt_lock);
+        lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
+
+        This->throw_if_destroyed("Item::move()");
+        new_parent_impl->throw_if_destroyed("Item::move()");
+
+        // TODO: This needs to deeply compare account identity because the client may have refreshed the accounts list.
+        if (This->root()->account() != new_parent->root()->account())  // Throws if account or runtime were destroyed.
         {
             // Can't do cross-account move.
-            QString msg = QString("Item::move(): Source (") + This->name_ + ") and target ("
+            QString msg = QString("Item::move(): source (") + This->name_ + ") and target ("
                           + new_name + ") must belong to the same account";
             throw LogicException(msg);
         }
         if (This->type_ == ItemType::root)
         {
             // Can't move a root.
-            throw LogicException("Item::move(): Cannot move root folder");
+            throw LogicException("Item::move(): cannot move root folder");
         }
 
         try
@@ -265,7 +254,7 @@
             }
             if (is_reserved_path(target_path))
             {
-                QString msg = "Item::move(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
+                QString msg = "Item::move(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
                 throw InvalidArgumentException(msg);
             }
             rename(This->native_identity().toStdString(), target_path);
@@ -276,9 +265,9 @@
             }
             return FileImpl::make_file(QString::fromStdString(target_path.native()), new_parent_impl->root_);
         }
-        catch (std::exception const& e)
+        catch (std::exception const&)
         {
-            throw ResourceException(QString("Item::move(): ") + e.what());
+            throw_storage_exception(QString("Item::move(): "), current_exception());
         }
     };
     return QtConcurrent::run(move);
@@ -286,18 +275,15 @@
 
 QFuture<QVector<Folder::SPtr>> ItemImpl::parents() const
 {
-    lock_guard<mutex> guard(mutex_);
+    lock_guard<decltype(mutex_)> guard(mutex_);
 
-    QFutureInterface<QVector<Folder::SPtr>> qf;
-    if (deleted_)
+    try
     {
-        return make_exceptional_future<QVector<Folder::SPtr>>(deleted_ex("Item::parents()"));
+        throw_if_destroyed("Item::parents()");
     }
-
-    Root::SPtr root = root_.lock();
-    if (!root)
+    catch (StorageException const& e)
     {
-        return make_exceptional_future<QVector<Folder::SPtr>>(RuntimeDestroyedException("Item::parents()"));
+        return internal::make_exceptional_future<QVector<Folder::SPtr>>(e);
     }
 
     using namespace boost::filesystem;
@@ -306,10 +292,11 @@
     path p = native_identity().toStdString();
     QString parent_path = QString::fromStdString(p.parent_path().native());
 
+    auto root = root_.lock();