Merge lp:~michihenning/storage-framework/merge-devel into lp:storage-framework

[Michi Henning]

Merged devel at r118 for 0.3 release.

Merged devel at r118 for 0.3 release.

[James Henstridge (jamesh)]

Looks good.

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2016-11-04 10:27:54 +0000
+++ .bzrignore	2017-03-20 04:58:30 +0000
@@ -1,3 +1,7 @@
 build
 debian/libstorage-framework-provider-1-*.install
 debian/libstorage-framework-provider-1-*.shlibs
+./parts
+./prime
+./stage
+./storage-framework*.snap

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-12-12 02:18:21 +0000
+++ CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -5,7 +5,7 @@
 endif()
 
 cmake_minimum_required(VERSION 3.0.2)
-project(storage-framework VERSION "0.2" LANGUAGES C CXX)
+project(storage-framework VERSION "0.3" LANGUAGES C CXX)
 
 # These variables should be incremented when we wish to create a new
 # source incompatible version of the library where users of the
@@ -43,7 +43,7 @@
 include_directories(include)
 include_directories(${CMAKE_BINARY_DIR}/include)  # For generated headers
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC --std=c++11 -Wall -pedantic -Wextra -fvisibility=hidden")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC --std=c++14 -Wall -pedantic -Wextra -fvisibility=hidden")
 
 # Some additional warnings not included by the general flags set above.
 set(EXTRA_C_WARNINGS "-Wcast-align -Wcast-qual -Wformat -Wredundant-decls -Wswitch-default")
@@ -106,6 +106,11 @@
 
 find_package(CoverageReport)
 
+option(SNAP_BUILD "Build for snap release")
+if("${SNAP_BUILD}")
+    add_definitions(-DSNAP_BUILD=1)
+endif()
+
 include(GNUInstallDirs)
 
 find_package(Boost 1.56 COMPONENTS filesystem system thread REQUIRED)
@@ -118,6 +123,7 @@
 
 include(FindPkgConfig)
 pkg_check_modules(APPARMOR_DEPS REQUIRED libapparmor)
+pkg_check_modules(GIO_DEPS REQUIRED gio-2.0 gio-unix-2.0)
 pkg_check_modules(GLIB_DEPS REQUIRED glib-2.0)
 pkg_check_modules(ONLINEACCOUNTS_DEPS REQUIRED OnlineAccountsQt)
 
@@ -128,9 +134,11 @@
 add_subdirectory(plugins/Ubuntu/StorageFramework)
 add_subdirectory(tests)
 add_subdirectory(demo)
+add_subdirectory(tools)
 
 enable_coverage_report(
     TARGETS
+        local-provider-lib
         qt-client-lib-common
         storage-framework-common-internal
         storage-framework-qt-client
@@ -138,7 +146,9 @@
         storage-framework-qt-local-client
         sf-provider-objects
         storage-framework-provider
+        registry-static
         storage-framework-registry
+        storage-provider-local
     FILTER
         ${CMAKE_SOURCE_DIR}/tests/*
         ${CMAKE_BINARY_DIR}/*

=== modified file 'CTestCustom.cmake.in'
--- CTestCustom.cmake.in	2016-04-20 00:53:53 +0000
+++ CTestCustom.cmake.in	2017-03-20 04:58:30 +0000
@@ -7,5 +7,21 @@
 #
 
 SET(CTEST_CUSTOM_MEMCHECK_IGNORE
+    clean-public-unity-storage-headers
+    clean-public-unity-storage-provider-headers
+    clean-public-unity-storage-qt-client-headers
+    clean-public-unity-storage-qt-headers
+    copyright
+    debian-version
+    stand-alone-unity-storage-headers
+    stand-alone-unity-storage-internal-headers
+    stand-alone-unity-storage-provider-headers
+    stand-alone-unity-storage-provider-internal-headers
+    stand-alone-unity-storage-qt-client-headers
+    stand-alone-unity-storage-qt-client-internal-headers
+    stand-alone-unity-storage-qt-client-internal-local_client-headers
+    stand-alone-unity-storage-qt-client-internal-remote_client-headers
+    stand-alone-unity-storage-qt-headers
+    stand-alone-unity-storage-qt-internal-headers
     whitespace
 )

=== modified file 'debian/changelog'
--- debian/changelog	2016-12-12 02:54:47 +0000
+++ debian/changelog	2017-03-20 04:58:30 +0000
@@ -1,3 +1,24 @@
+storage-framework (0.3-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ James Henstridge ]
+  * Make providers exit after 30 seconds of inactivity. (LP: #1616758)
+  * Add UnauthorizedException to the provider library, so the provider
+    can trigger reauthentication of the account and have the request
+    restarted. (LP: #1616756)
+  * Dynamically add and remove providers as the associated accounts
+    are enabled and disabled. (LP: #1616757)
+  * Allow creation of storage providers that don't use online-accounts.
+    Thisis likely only of interest to the local storage provider.
+
+  [ Michi Henning ]
+  * Add a storage provider backed by the local file system.
+  * Move unity::storage::provider::Item to its own header file. (LP:
+    #1668872)
+  * If a provider can't acquire its D-Bus well known name, exit rather
+    than throwing a (usually uncaught) exception. (LP: #1604640)
+
+ -- James Henstridge <[e-mail]>  Tue, 20 Dec 2016 11:46:21 +0800
+
 storage-framework (0.2+17.04.20161212.1-0ubuntu1) zesty; urgency=medium
 
   * Fix for lp:1644577, fail list job if metadata for any item is incorrect.

=== modified file 'debian/control.in'
--- debian/control.in	2016-12-12 02:18:21 +0000
+++ debian/control.in	2017-03-20 04:58:30 +0000
@@ -2,7 +2,7 @@
 Section: libs
 Priority: optional
 Maintainer: Ubuntu Core Developers <[e-mail]>
-Standards-Version: 3.9.6
+Standards-Version: 3.9.7
 Build-Depends: cmake,
                cmake-extras (>= 0.10),
                debhelper (>= 9),
@@ -58,6 +58,7 @@
          online-accounts-daemon,
 Description: Registry for the Storage Framework
  DBus service that provides access to provider account information.
+ Includes a local storage provider.
 
 Package: libstorage-framework-qt-client-2-0
 Architecture: any

=== modified file 'debian/storage-framework-registry.install'
--- debian/storage-framework-registry.install	2016-11-21 04:37:37 +0000
+++ debian/storage-framework-registry.install	2017-03-20 04:58:30 +0000
@@ -1,2 +1,4 @@
 usr/lib/*/*/storage-framework-registry
 usr/share/dbus-1/services/com.canonical.StorageFramework.Registry.service
+usr/lib/*/*/storage-provider-local
+usr/share/dbus-1/services/com.canonical.StorageFramework.Provider.Local.service

=== modified file 'demo/provider_test/provider-test.cpp'
--- demo/provider_test/provider-test.cpp	2016-11-15 05:48:12 +0000
+++ demo/provider_test/provider-test.cpp	2017-03-20 04:58:30 +0000
@@ -321,5 +321,5 @@
     }
     Server<MyProvider> server(bus_name, account_service_id);
     server.init(argc, argv);
-    server.run();
+    return server.run();
 }

=== modified file 'include/unity/storage/internal/ActivityNotifier.h'
--- include/unity/storage/internal/ActivityNotifier.h	2016-11-08 11:17:52 +0000
+++ include/unity/storage/internal/ActivityNotifier.h	2017-03-20 04:58:30 +0000
@@ -35,6 +35,8 @@
 class ActivityNotifier
 {
 public:
+    ActivityNotifier() = default;
+
     ActivityNotifier(std::shared_ptr<InactivityTimer> const& timer)
         : timer_(timer)
     {
@@ -43,9 +45,26 @@
         timer_->request_started();
     }
 
+    ActivityNotifier(ActivityNotifier&& other)
+        : timer_(std::move(other.timer_))
+    {
+    }
+
+    ActivityNotifier& operator=(ActivityNotifier&& other)
+    {
+        timer_ = std::move(other.timer_);
+        return *this;
+    }
+
+    ActivityNotifier(ActivityNotifier const&) = delete;
+    ActivityNotifier& operator=(ActivityNotifier const&) = delete;
+
     ~ActivityNotifier()
     {
-        timer_->request_finished();
+        if (timer_)
+        {
+            timer_->request_finished();
+        }
     }
 
 private:

=== modified file 'include/unity/storage/internal/EnvVars.h'
--- include/unity/storage/internal/EnvVars.h	2016-11-21 13:29:39 +0000
+++ include/unity/storage/internal/EnvVars.h	2017-03-20 04:58:30 +0000
@@ -32,6 +32,9 @@
 constexpr char const* REGISTRY_IDLE_TIMEOUT = "SF_REGISTRY_IDLE_TIMEOUT";  // Seconds, 0 means "never"
 constexpr int REGISTRY_IDLE_TIMEOUT_DFLT = 30;
 
+constexpr char PROVIDER_IDLE_TIMEOUT[] = "SF_PROVIDER_IDLE_TIMEOUT";
+constexpr int PROVIDER_IDLE_TIMEOUT_DFLT = 30;
+
 // Helper class to make retrieval of environment variables type-safe and
 // to sanity check the setting, if applicable. Also returns a default
 // setting, if applicable.
@@ -40,10 +43,14 @@
 {
 public:
     static int registry_timeout_ms();
+    static int provider_timeout_ms();
 
     // Returns value of var_name in the environment, if set, and an empty string otherwise.
     // Can be used for any environment variable, not just the ones defined above.
     static std::string get(char const* var_name);
+
+private:
+    static int get_timeout_ms(char const* var_name, int dflt);
 };
 
 }  // namespace internal

=== modified file 'include/unity/storage/internal/InactivityTimer.h'
--- include/unity/storage/internal/InactivityTimer.h	2016-11-08 11:17:52 +0000
+++ include/unity/storage/internal/InactivityTimer.h	2017-03-20 04:58:30 +0000
@@ -39,20 +39,18 @@
     Q_OBJECT
 
 public:
-    InactivityTimer(int timeout_ms, std::function<void()> timeout_func);
+    InactivityTimer(int timeout_ms);
     ~InactivityTimer();
 
     void request_started();
     void request_finished();
 
-private Q_SLOTS:
+Q_SIGNALS:
     void timeout();
 
 private:
-    int timeout_ms_;
-    std::function<void()> timeout_func_;
     QTimer timer_;
-    int32_t num_requests_;
+    int32_t num_requests_ = 0;
 };
 
 }  // namespace internal

=== added file 'include/unity/storage/internal/gobj_memory.h'
--- include/unity/storage/internal/gobj_memory.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/internal/gobj_memory.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2013 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#pragma once
+
+#include <stdexcept>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#include <glib-object.h>
+
+namespace unity
+{
+
+namespace storage
+{
+
+namespace internal
+{
+
+/**
+ * This class is meant for automatically managing the lifetime of C objects derived
+ * from gobject. Its API perfectly mirrors the API of unique_ptr except that you
+ * can't define your own deleter function as it is always g_object_unref.
+ *
+ * API/ABI stability is not guaranteed. If you need to pass the object across an ABI
+ * boundary, pass the plain gobject.
+ *
+ * This is how you would use gobj_ptr 99% of the time:
+ *
+ * gobj_ptr<GSomeType> o(g_some_type_new(...));
+ *
+ * More specifically, the object will decrement the gobject reference count
+ * of the object it points to when it goes out of scope. It will never increment it.
+ * Thus you should only assign to it when already holding a reference. gobj_ptr
+ * will then take ownership of that particular reference.
+ *
+ * Floating gobjects can not be put in this container as they are meant to be put
+ * into native gobject aware containers immediately upon construction. Trying to insert
+ * a floating gobject into a gobj_ptr will throw an invalid_argument exception. To
+ * prevent accidental memory leaks, the floating gobject is unreffed in this case.
+ */
+template <typename T>
+class gobj_ptr final
+{
+private:
+    T* u;
+
+    void validate_float(T* t)
+    {
+        if (t != nullptr && g_object_is_floating(G_OBJECT(t)))
+        {
+            // LCOV_EXCL_START  // False negative from gcovr.
+            throw std::invalid_argument("Tried to add a floating gobject into a gobj_ptr.");
+            // LCOV_EXCL_STOP
+        }
+    }
+
+public:
+    typedef T element_type;
+    typedef T* pointer;
+    typedef decltype(g_object_unref) deleter_type;
+
+    constexpr gobj_ptr() noexcept : u(nullptr)
+    {
+    }
+    explicit gobj_ptr(T* t)
+        : u(t)
+    {
+        // What should we do if validate throws? Unreffing unknown objs
+        // is dodgy but not unreffing runs the risk of
+        // memory leaks. Currently unrefs as u is destroyed
+        // when this exception is thrown.
+        validate_float(t);
+    }
+    constexpr gobj_ptr(std::nullptr_t) noexcept : u(nullptr){};
+    gobj_ptr(gobj_ptr&& o) noexcept
+    {
+        u = o.u;
+        o.u = nullptr;
+    }
+    gobj_ptr(const gobj_ptr& o)
+        : u(nullptr)
+    {
+        *this = o;
+    }
+    gobj_ptr& operator=(const gobj_ptr& o)
+    {
+        if (o.u != nullptr)
+        {
+            g_object_ref(o.u);
+        }
+        reset(o.u);
+        return *this;
+    }
+    ~gobj_ptr()
+    {
+        reset();
+    }
+
+    deleter_type& get_deleter() noexcept
+    {
+        return g_object_unref;
+    }
+    deleter_type& get_deleter() const noexcept
+    {
+        return g_object_unref;
+    }
+
+    void swap(gobj_ptr<T>& o) noexcept
+    {
+        T* tmp = u;
+        u = o.u;
+        o.u = tmp;
+    }
+    void reset(pointer p = pointer())
+    {
+        if (u != nullptr)
+        {
+            g_object_unref(G_OBJECT(u));
+            u = nullptr;
+        }
+        // Same throw dilemma as in pointer constructor.
+        u = p;
+        validate_float(p);
+    }
+
+    T* release() noexcept
+    {
+        T* r = u;
+        u = nullptr;
+        return r;
+    }
+    T* get() const noexcept
+    {
+        return u;
+    }
+
+    T& operator*() const
+    {
+        return *u;
+    }
+    T* operator->() const noexcept
+    {
+        return u;
+    }
+    explicit operator bool() const noexcept
+    {
+        return u != nullptr;
+    }
+
+    gobj_ptr& operator=(gobj_ptr&& o) noexcept
+    {
+        reset();
+        u = o.u;
+        o.u = nullptr;
+        return *this;
+    }
+    gobj_ptr& operator=(std::nullptr_t) noexcept
+    {
+        reset();
+        return *this;
+    }
+    bool operator==(const gobj_ptr<T>& o) const noexcept
+    {
+        return u == o.u;
+    }
+    bool operator!=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u != o.u;
+    }
+    bool operator<(const gobj_ptr<T>& o) const noexcept
+    {
+        return u < o.u;
+    }
+    bool operator<=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u <= o.u;
+    }
+    bool operator>(const gobj_ptr<T>& o) const noexcept
+    {
+        return u > o.u;
+    }
+    bool operator>=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u >= o.u;
+    }
+};
+
+}  // namespace internal
+
+}  // namespace storage
+
+}  // namespace unity
+
+#pragma GCC diagnostic pop

=== modified file 'include/unity/storage/provider/Exceptions.h'
--- include/unity/storage/provider/Exceptions.h	2016-08-05 05:37:23 +0000
+++ include/unity/storage/provider/Exceptions.h	2017-03-20 04:58:30 +0000
@@ -95,7 +95,7 @@
 };
 
 /**
-\brief Indicates that an upload detected a version mismatch.
+\brief Indicates that an upload or download detected a version mismatch.
 */
 class UNITY_STORAGE_EXPORT ConflictException : public StorageException
 {
@@ -105,7 +105,37 @@
 };
 
 /**
+\brief Indicates that an operation failed because the authentication credentials are invalid or expired.
+
+A provider implementation must throw this exception if it cannot reach
+its provider because the credentials are invalid. Do not throw this
+exception if the credentials are valid, but an operation failed due to
+insufficient permission for an item (such as an attempt to write to a
+read-only file).
+
+Typically, this will cause the request to be retried after refreshing
+the authentication credentials, but may be returned to the client on
+repeated failures.
+
+\see PermissionException
+*/
+class UNITY_STORAGE_EXPORT UnauthorizedException : public StorageException
+{
+public:
+    UnauthorizedException(std::string const& error_message);
+    ~UnauthorizedException();
+};
+
+/**
 \brief Indicates that an operation failed because of a permission problem.
+
+A provider implementation must throw this exception if it can
+authenticate with its provider, but the provider denied the operation
+due to insufficient permission for an item (such as an attempt to
+write to a read-only file). Do not throw this exception for failure to
+authenticate with the provider.
+
+\see UnauthorizedException
 */
 class UNITY_STORAGE_EXPORT PermissionException : public StorageException
 {

=== added file 'include/unity/storage/provider/Item.h'
--- include/unity/storage/provider/Item.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/Item.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,54 @@
+/*
+ * 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/common.h>
+#include <unity/storage/visibility.h>
+
+#include <boost/variant.hpp>
+
+#include <map>
+#include <vector>
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+
+// 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::vector<std::string> parent_ids;
+    std::string name;
+    std::string etag;
+    unity::storage::ItemType type;
+    std::map<std::string, MetadataValue> metadata;
+};
+
+typedef std::vector<Item> ItemList;
+
+}
+}
+}

=== modified file 'include/unity/storage/provider/ProviderBase.h'
--- include/unity/storage/provider/ProviderBase.h	2016-11-03 02:43:43 +0000
+++ include/unity/storage/provider/ProviderBase.h	2017-03-20 04:58:30 +0000
@@ -21,6 +21,7 @@
 #include <unity/storage/common.h>
 #include <unity/storage/visibility.h>
 #include <unity/storage/provider/Credentials.h>
+#include <unity/storage/provider/Item.h>
 
 #include <boost/thread/future.hpp>
 #include <boost/variant.hpp>
@@ -50,22 +51,6 @@
     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::vector<std::string> parent_ids;
-    std::string name;
-    std::string etag;
-    unity::storage::ItemType type;
-    std::map<std::string, MetadataValue> metadata;
-};
-
-typedef std::vector<Item> ItemList;
-
 class UNITY_STORAGE_EXPORT ProviderBase : public std::enable_shared_from_this<ProviderBase>
 {
 public:

=== modified file 'include/unity/storage/provider/Server.h'
--- include/unity/storage/provider/Server.h	2016-09-28 07:04:41 +0000
+++ include/unity/storage/provider/Server.h	2017-03-20 04:58:30 +0000
@@ -44,7 +44,7 @@
     virtual ~ServerBase();
 
     void init(int& argc, char** argv);
-    void run();
+    int run();
 
 protected:
     virtual std::shared_ptr<ProviderBase> make_provider() = 0;

=== modified file 'include/unity/storage/provider/internal/AccountData.h'
--- include/unity/storage/provider/internal/AccountData.h	2016-09-28 10:03:40 +0000
+++ include/unity/storage/provider/internal/AccountData.h	2017-03-20 04:58:30 +0000
@@ -24,19 +24,20 @@
 #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>
-#include <QPointer>
 #pragma GCC diagnostic pop
 
-#include <string>
-
 namespace unity
 {
 namespace storage
 {
+namespace internal
+{
+
+class InactivityTimer;
+
+}
 namespace provider
 {
 
@@ -54,37 +55,29 @@
 public:
     AccountData(std::shared_ptr<ProviderBase> const& provider,
                 std::shared_ptr<DBusPeerCache> const& dbus_peer,
+                std::shared_ptr<unity::storage::internal::InactivityTimer> const& inactivity_timer,
                 QDBusConnection const& bus,
-                OnlineAccounts::Account* account,
                 QObject* parent=nullptr);
     virtual ~AccountData();
 
-    void authenticate(bool interactive);
-    bool has_credentials();
-    Credentials const& credentials();
+    virtual void authenticate(bool interactive, bool invalidate_cache=false) = 0;
+    virtual bool has_credentials() = 0;
+    virtual Credentials const& credentials() = 0;
 
     ProviderBase& provider();
     DBusPeerCache& dbus_peer();
+    std::shared_ptr<unity::storage::internal::InactivityTimer> inactivity_timer();
     PendingJobs& jobs();
 
 Q_SIGNALS:
     void authenticated();
 
-private Q_SLOTS:
-    void on_authenticated();
-
 private:
     std::shared_ptr<ProviderBase> const provider_;
     std::shared_ptr<DBusPeerCache> const dbus_peer_;
+    std::shared_ptr<unity::storage::internal::InactivityTimer> const inactivity_timer_;
     std::unique_ptr<PendingJobs> const jobs_;
 
-    QPointer<OnlineAccounts::Account> const account_;
-    std::unique_ptr<OnlineAccounts::PendingCallWatcher> auth_watcher_;
-    bool authenticating_interactively_ = false;
-
-    bool credentials_valid_ = false;
-    Credentials credentials_;
-
     Q_DISABLE_COPY(AccountData)
 };
 

=== modified file 'include/unity/storage/provider/internal/DownloadJobImpl.h'
--- include/unity/storage/provider/internal/DownloadJobImpl.h	2016-09-02 13:51:37 +0000
+++ include/unity/storage/provider/internal/DownloadJobImpl.h	2017-03-20 04:58:30 +0000
@@ -18,6 +18,8 @@
 
 #pragma once
 
+#include <unity/storage/internal/ActivityNotifier.h>
+
 #include <QObject>
 
 #include <boost/thread/future.hpp>
@@ -47,6 +49,7 @@
     std::string const& download_id() const;
     int write_socket() const;
     int take_read_socket();
+    void set_activity(std::shared_ptr<unity::storage::internal::InactivityTimer> const& inactivity_timer);
 
     void report_complete();
     void report_error(std::exception_ptr p);
@@ -65,6 +68,8 @@
     bool completed_ = false;
     boost::promise<void> completion_promise_;
 
+    unity::storage::internal::ActivityNotifier activity_;
+
     Q_DISABLE_COPY(DownloadJobImpl)
 };
 

=== added file 'include/unity/storage/provider/internal/FixedAccountData.h'
--- include/unity/storage/provider/internal/FixedAccountData.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/internal/FixedAccountData.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2017 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/internal/AccountData.h>
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+namespace internal
+{
+
+class FixedAccountData : public AccountData
+{
+    Q_OBJECT
+public:
+    FixedAccountData(std::shared_ptr<ProviderBase> const& provider,
+                      std::shared_ptr<DBusPeerCache> const& dbus_peer,
+                      std::shared_ptr<unity::storage::internal::InactivityTimer> const& inactivity_timer,
+                      QDBusConnection const& bus,
+                      QObject* parent=nullptr);
+    virtual ~FixedAccountData();
+
+    void authenticate(bool interactive, bool invalidate_cache=false) override;
+    bool has_credentials() override;
+    Credentials const& credentials() override;
+
+private:
+    Credentials credentials_ = boost::blank();
+
+    Q_DISABLE_COPY(FixedAccountData)
+};
+
+}
+}
+}
+}

=== modified file 'include/unity/storage/provider/internal/Handler.h'
--- include/unity/storage/provider/internal/Handler.h	2016-08-05 05:37:23 +0000
+++ include/unity/storage/provider/internal/Handler.h	2017-03-20 04:58:30 +0000
@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <unity/storage/internal/ActivityNotifier.h>
 #include <unity/storage/provider/ProviderBase.h>
 #include <unity/storage/provider/internal/DBusPeerCache.h>
 
@@ -52,11 +53,12 @@
             Callback const& callback,
             QDBusConnection const& bus, QDBusMessage const& message);
 
-public Q_SLOTS:
     void begin();
 
 private Q_SLOTS:
+    void on_authenticated();
     void credentials_received();
+    void handle_unauthorized(std::exception_ptr ep);
     void send_reply();
 
 Q_SIGNALS:
@@ -69,11 +71,13 @@
     Callback const callback_;
     QDBusConnection const bus_;
     QDBusMessage const message_;
+    unity::storage::internal::ActivityNotifier activity_;
 
     boost::future<void> creds_future_;
     boost::future<void> reply_future_;
     Context context_;
     QDBusMessage reply_;
+    bool retry_ = false;
 
     Q_DISABLE_COPY(Handler)
 };
@@ -82,3 +86,5 @@
 }
 }
 }
+
+Q_DECLARE_METATYPE(std::exception_ptr)

=== added file 'include/unity/storage/provider/internal/OnlineAccountData.h'
--- include/unity/storage/provider/internal/OnlineAccountData.h	1970-01-01 00:00:00 +0000
+++ include/unity/storage/provider/internal/OnlineAccountData.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2017 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/internal/AccountData.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 <QPointer>
+#pragma GCC diagnostic pop
+
+namespace unity
+{
+namespace storage
+{
+namespace provider
+{
+namespace internal
+{
+
+class OnlineAccountData : public AccountData
+{
+    Q_OBJECT
+public:
+    OnlineAccountData(std::shared_ptr<ProviderBase> const& provider,
+                      std::shared_ptr<DBusPeerCache> const& dbus_peer,
+                      std::shared_ptr<unity::storage::internal::InactivityTimer> const& inactivity_timer,
+                      QDBusConnection const& bus,
+                      OnlineAccounts::Account* account,
+                      QObject* parent=nullptr);
+    virtual ~OnlineAccountData();
+
+    void authenticate(bool interactive, bool invalidate_cache=false) override;
+    bool has_credentials() override;
+    Credentials const& credentials() override;
+
+private Q_SLOTS:
+    void on_authenticated();
+    void on_changed();
+
+private:
+    QPointer<OnlineAccounts::Account> const account_;
+    std::unique_ptr<OnlineAccounts::PendingCallWatcher> auth_watcher_;
+    bool authenticating_interactively_ = false;
+    bool authenticating_invalidate_cache_ = false;
+
+    Credentials credentials_ = boost::blank();
+
+    Q_DISABLE_COPY(OnlineAccountData)
+};
+
+}
+}
+}
+}

=== modified file 'include/unity/storage/provider/internal/ServerImpl.h'
--- include/unity/storage/provider/internal/ServerImpl.h	2016-08-12 06:19:22 +0000
+++ include/unity/storage/provider/internal/ServerImpl.h	2017-03-20 04:58:30 +0000
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <unity/storage/provider/Server.h>
+#include <unity/storage/internal/InactivityTimer.h>
 #include <unity/storage/internal/TraceMessageHandler.h>
 #include <unity/storage/provider/internal/DBusPeerCache.h>
 #include <unity/storage/provider/internal/ProviderInterface.h>
@@ -49,19 +50,32 @@
     ServerImpl(ServerBase* server, std::string const& bus_name, std::string const& account_service_id);
     ~ServerImpl();
 
-    void init(int& argc, char **argv);
-    void run();
+    void init(int& argc, char **argv, QDBusConnection *bus = nullptr);
+    int run();
 
 private Q_SLOTS:
-    void account_manager_ready();
+    void on_account_manager_ready();
+    void on_account_available(OnlineAccounts::Account* account);
+    void on_account_disabled();
+    void on_timeout();
+
+Q_SIGNALS:
+    void accountAdded();
+    void accountRemoved();
 
 private:
+    void register_bus_name();
+    void add_account(OnlineAccounts::Account* account);
+    void remove_account(OnlineAccounts::Account* account);
+
     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<QDBusConnection> bus_;
+    std::shared_ptr<unity::storage::internal::InactivityTimer> inactivity_timer_;
     std::unique_ptr<OnlineAccounts::Manager> manager_;
     std::shared_ptr<DBusPeerCache> dbus_peer_;
     std::map<OnlineAccounts::AccountId,std::unique_ptr<ProviderInterface>> interfaces_;

=== modified file 'include/unity/storage/provider/internal/TestServerImpl.h'
--- include/unity/storage/provider/internal/TestServerImpl.h	2016-09-28 07:04:41 +0000
+++ include/unity/storage/provider/internal/TestServerImpl.h	2017-03-20 04:58:30 +0000
@@ -33,6 +33,12 @@
 {
 namespace storage
 {
+namespace internal
+{
+
+class InactivityTimer;
+
+}
 namespace provider
 {
 namespace internal
@@ -56,6 +62,7 @@
     QDBusConnection connection_;
     std::string const object_path_;
 
+    std::shared_ptr<unity::storage::internal::InactivityTimer> inactivity_timer_;
     std::unique_ptr<ProviderInterface> interface_;
 };
 

=== modified file 'include/unity/storage/provider/internal/UploadJobImpl.h'
--- include/unity/storage/provider/internal/UploadJobImpl.h	2016-09-02 13:51:37 +0000
+++ include/unity/storage/provider/internal/UploadJobImpl.h	2017-03-20 04:58:30 +0000
@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <unity/storage/internal/ActivityNotifier.h>
 #include <unity/storage/provider/ProviderBase.h>
 
 #include <boost/thread/future.hpp>
@@ -28,6 +29,7 @@
 #pragma GCC diagnostic pop
 
 #include <exception>
+#include <memory>
 #include <mutex>
 #include <string>
 
@@ -52,6 +54,7 @@
     std::string const& upload_id() const;
     int read_socket() const;
     int take_write_socket();
+    void set_activity(std::shared_ptr<unity::storage::internal::InactivityTimer> const& inactivity_timer);
 
     void report_error(std::exception_ptr p);
     boost::future<Item> finish(UploadJob& job);
@@ -69,6 +72,8 @@
     bool completed_ = false;
     boost::promise<Item> completion_promise_;
 
+    unity::storage::internal::ActivityNotifier activity_;
+
     Q_DISABLE_COPY(UploadJobImpl)
 };
 

=== modified file 'include/unity/storage/qt/StorageError.h'
--- include/unity/storage/qt/StorageError.h	2016-10-12 06:05:29 +0000
+++ include/unity/storage/qt/StorageError.h	2017-03-20 04:58:30 +0000
@@ -58,8 +58,9 @@
 
     enum Type
     {
-        NoError, LocalCommsError, RemoteCommsError, RuntimeDestroyed, NotExists, Exists, Conflict,
-        PermissionDenied, Cancelled, LogicError, InvalidArgument, ResourceError, QuotaExceeded,
+        NoError, LocalCommsError, RemoteCommsError, RuntimeDestroyed,
+        NotExists, Exists, Conflict, PermissionDenied, Cancelled, LogicError,
+        InvalidArgument, ResourceError, QuotaExceeded, Unauthorized,
         __LAST_STORAGE_ERROR
     };
     Q_ENUMS(Type)

=== modified file 'include/unity/storage/registry/Registry.h'
--- include/unity/storage/registry/Registry.h	2016-11-22 07:23:48 +0000
+++ include/unity/storage/registry/Registry.h	2017-03-20 04:58:30 +0000
@@ -29,6 +29,7 @@
 
 static QString const BUS_NAME(QStringLiteral("com.canonical.StorageFramework.Registry"));
 static QString const OBJECT_PATH(QStringLiteral("/com/canonical/StorageFramework/Registry"));
+static QString const INTERFACE(QStringLiteral("com.canonical.StorageFramework.Registry"));
 
 }  // namespace registry
 }  // namespace storage

=== added directory 'snap'
=== added file 'snap/snapcraft.yaml'
--- snap/snapcraft.yaml	1970-01-01 00:00:00 +0000
+++ snap/snapcraft.yaml	2017-03-20 04:58:30 +0000
@@ -0,0 +1,128 @@
+name: storage-framework-service
+version: '0.2'
+summary: Service for accessing cloud-based storage providers.
+description: >
+  This snap provides a service to access cloud-based storage providers, such as
+  OneDrive, Owncloud, Google Drive, or mCloud, plus a client-side API for applications.
+  See lp:storage-framework for details on the framework, as well as
+  lp:storage-provider-onedrive, lp:storage-provider-webdav, lp:storage-provider-gdrive,
+  and lp:mcloud.
+grade: devel
+confinement: strict
+
+slots:
+  storage-framework-service:
+    interface: storage-framework-service
+  # Allow clients access to the client library
+  client-libs:
+    interface: content
+    content: client-libs
+    read:
+      - $SNAP/client
+  # Allow providers access to the provider library
+  provider-libs:
+    interface: content
+    content: provider-libs
+    read:
+      - $SNAP/provider
+
+plugs:
+  platform:
+    interface: content
+    content: ubuntu-app-platform1
+    target: ubuntu-app-platform
+    default-provider: ubuntu-app-platform
+
+apps:
+  storage-framework-registry:
+    command: desktop-launch $SNAP/lib/storage-framework/storage-framework-registry
+    plugs:
+      - platform
+    slots:
+      - storage-framework-service
+  storage-provider-owncloud:
+    # snap-launch sets LD_LIBRARY_PATH to include the provider directory (exposed via content interface).
+    command: snap-launch $SNAP/provider/lib $SNAP/lib/storage-provider-webdav/storage-provider-owncloud
+    plugs:
+      - platform
+      - network
+    slots:
+      - storage-framework-service
+
+parts:
+  storage-framework:
+    plugin: cmake
+    configflags:
+      - -DSNAP_BUILD=1
+    source: .
+    after:
+      - desktop-ubuntu-app-platform
+    organize:
+      lib/libstorage-framework-qt*: client/lib/
+      lib/libstorage-framework-provider*: provider/lib/
+    filesets:
+      binaries:
+        - bin/snap-launch
+        - lib/storage-framework/*
+        - client/*
+        - provider/*
+        - -lib/pkgconfig
+      dbus:
+        - share/dbus-1/services/com.canonical.StorageFramework.*
+    install: |
+      # Make sure we have a mount point for ubuntu-app-platform
+      mkdir -p $SNAPCRAFT_PART_INSTALL/ubuntu-app-platform
+      # Fix pkgconfig files to point at the parts subtree so
+      # the providers will build correctly.
+      sed -e "s@-I/include@-I${SNAPCRAFT_PART_INSTALL}/include@" \
+          -e "s@-L/lib@-L${SNAPCRAFT_PART_INSTALL}/provider/lib@" \
+          -i $SNAPCRAFT_PART_INSTALL/lib/pkgconfig/storage-framework-provider-1.pc
+      sed -e "s@-I/include@-I${SNAPCRAFT_PART_INSTALL}/include@" \
+          -e "s@-L/lib@-L${SNAPCRAFT_PART_INSTALL}/client/lib@" \
+          -i $SNAPCRAFT_PART_INSTALL/lib/pkgconfig/storage-framework-qt-local-client-1.pc
+      sed -e "s@-I/include@-I${SNAPCRAFT_PART_INSTALL}/include@" \
+          -e "s@-L/lib@-L${SNAPCRAFT_PART_INSTALL}/client/lib@" \
+          -i $SNAPCRAFT_PART_INSTALL/lib/pkgconfig/storage-framework-qt-client-1.pc
+      sed -e "s@-I/include@-I${SNAPCRAFT_PART_INSTALL}/include@" \
+          -e "s@-L/lib@-L${SNAPCRAFT_PART_INSTALL}/client/lib@" \
+          -i $SNAPCRAFT_PART_INSTALL/lib/pkgconfig/storage-framework-qt-client-2.pc
+    prime:
+      - $binaries
+      - ubuntu-app-platform
+
+    build-packages:
+      - cmake-extras
+      - doxygen
+      - google-mock
+      - libapparmor-dev
+      - libboost-filesystem-dev
+      - libboost-system-dev
+      - libboost-thread-dev
+      - libglib2.0-dev
+      - libgtest-dev
+      - libonline-accounts-qt-dev
+      - libqtdbustest1-dev
+      - libunity-api-dev
+      - lsb-release
+      - python3-dbus
+      - python3-gi
+      - qtbase5-dev
+      - qtbase5-dev-tools
+      - qtdeclarative5-dev
+
+  # For now, the providers are part of the storage-framework snap. Eventually, they will have to each
+  # live inside their own snap.
+  storage-provider-owncloud:
+    plugin: cmake
+    configflags:
+      - -DSNAP_BUILD=1
+    source: lp:storage-provider-webdav
+    after:
+      - storage-framework
+    filesets:
+      binaries:
+        - lib/storage-provider-webdav/*
+    prime:
+      - $binaries
+
+# TODO: Add other providers (OneDrive, Google Drive, mCloud)

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-11-07 04:49:34 +0000
+++ src/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -2,3 +2,4 @@
 add_subdirectory(provider)
 add_subdirectory(qt)
 add_subdirectory(registry)
+add_subdirectory(local-provider)

=== modified file 'src/internal/EnvVars.cpp'
--- src/internal/EnvVars.cpp	2016-11-21 13:29:39 +0000
+++ src/internal/EnvVars.cpp	2017-03-20 04:58:30 +0000
@@ -34,34 +34,44 @@
 
 int EnvVars::registry_timeout_ms()
 {
-    int const dflt_val = REGISTRY_IDLE_TIMEOUT_DFLT * 1000;
-
-    auto const val = get(REGISTRY_IDLE_TIMEOUT);
-    if (val.empty())
-    {
-        return dflt_val;
-    }
-    try
-    {
-        size_t pos;
-        auto int_val = stoi(val, &pos);
-        if (pos != val.size())
-        {
-            throw invalid_argument("unexpected trailing character(s)");
-        }
-        if (int_val < 0)
-        {
-            throw invalid_argument("value must be >= 0");
-        }
-        return int_val;
-    }
-    catch (std::exception const& e)
-    {
-        qWarning().noquote().nospace() << "Invalid setting of env var " << QString::fromStdString(REGISTRY_IDLE_TIMEOUT)
-                                       << " (\"" << QString::fromStdString(val) << "\"): " << e.what();
-        qWarning().nospace() << "Using default value of " << REGISTRY_IDLE_TIMEOUT_DFLT;
-    }
-    return dflt_val;
+    return get_timeout_ms(REGISTRY_IDLE_TIMEOUT, REGISTRY_IDLE_TIMEOUT_DFLT);
+}
+
+int EnvVars::provider_timeout_ms()
+{
+    return get_timeout_ms(PROVIDER_IDLE_TIMEOUT, PROVIDER_IDLE_TIMEOUT_DFLT);
+}
+
+int EnvVars::get_timeout_ms(char const* var_name, int dflt)
+{
+    int timeout = dflt;
+
+    auto const val = get(var_name);
+    if (!val.empty())
+    {
+        try
+        {
+            size_t pos;
+            auto int_val = stoi(val, &pos);
+            if (pos != val.size())
+            {
+                throw invalid_argument("unexpected trailing character(s)");
+            }
+            if (int_val < 0)
+            {
+                throw invalid_argument("value must be >= 0");
+            }
+            timeout = int_val;
+        }
+        catch (std::exception const& e)
+        {
+            qWarning().noquote().nospace()
+                << "Invalid setting of env var " << var_name
+                << " (\"" << QString::fromStdString(val) << "\"): " << e.what();
+            qWarning().nospace() << "Using default value of " << dflt;
+        }
+    }
+    return timeout * 1000;
 }
 
 string EnvVars::get(char const* var_name)

=== modified file 'src/internal/InactivityTimer.cpp'
--- src/internal/InactivityTimer.cpp	2016-11-08 11:17:52 +0000
+++ src/internal/InactivityTimer.cpp	2017-03-20 04:58:30 +0000
@@ -18,8 +18,6 @@
 
 #include <unity/storage/internal/InactivityTimer.h>
 
-#include <QDebug>
-
 #include <cassert>
 
 namespace unity
@@ -29,14 +27,12 @@
 namespace internal
 {
 
-InactivityTimer::InactivityTimer(int timeout_ms, std::function<void()> timeout_func)
-    : timeout_ms_(timeout_ms)
-    , timeout_func_(timeout_func)
-    , num_requests_(0)
+InactivityTimer::InactivityTimer(int timeout_ms)
 {
-    assert(timeout_ms_ >= 0);
-    assert(timeout_func);
+    assert(timeout_ms >= 0);
 
+    timer_.setInterval(timeout_ms);
+    timer_.setSingleShot(true);
     connect(&timer_, &QTimer::timeout, this, &InactivityTimer::timeout);
 }
 
@@ -58,22 +54,7 @@
 
     if (--num_requests_ == 0)
     {
-        timer_.start(timeout_ms_);
-    }
-}
-
-void InactivityTimer::timeout()
-{
-    timer_.stop();
-    disconnect(this);
-    try
-    {
-        timeout_func_();
-    }
-    catch (std::exception const& e)
-    {
-        auto msg = QString("InactivityTimer::timeout(): exception from timeout callback: ") + e.what();
-        qWarning().nospace() << msg;
+        timer_.start();
     }
 }
 

=== added directory 'src/local-provider'
=== added file 'src/local-provider/CMakeLists.txt'
--- src/local-provider/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/local-provider/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -0,0 +1,43 @@
+add_definitions(-DBOOST_THREAD_VERSION=4)
+
+add_library(local-provider-lib STATIC
+    LocalDownloadJob.cpp
+    LocalProvider.cpp
+    LocalUploadJob.cpp
+    utils.cpp
+)
+
+target_include_directories(local-provider-lib PRIVATE
+    ${Qt5Network_INCLUDE_DIRS}
+    ${GLIB_DEPS_INCLUDE_DIRS}
+    ${GIO_DEPS_INCLUDE_DIRS}
+)
+
+set_target_properties(local-provider-lib PROPERTIES
+    AUTOMOC TRUE
+    POSITION_INDEPENDENT_CODE TRUE
+)
+
+add_executable(storage-provider-local
+    main.cpp
+)
+
+target_link_libraries(storage-provider-local
+    local-provider-lib
+    storage-framework-provider
+    Qt5::Network
+    ${GLIB_DEPS_LIBRARIES}
+    ${GIO_DEPS_LIBRARIES}
+)
+
+install(
+    TARGETS storage-provider-local
+    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}
+)
+
+configure_file(com.canonical.StorageFramework.Provider.Local.service.in com.canonical.StorageFramework.Provider.Local.service)
+
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.StorageFramework.Provider.Local.service
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services
+)

=== added file 'src/local-provider/LocalDownloadJob.cpp'
--- src/local-provider/LocalDownloadJob.cpp	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalDownloadJob.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2017 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 "LocalDownloadJob.h"
+
+#include "LocalProvider.h"
+#include "utils.h"
+#include <unity/storage/internal/safe_strerror.h>
+#include <unity/storage/provider/Exceptions.h>
+
+using namespace unity::storage::provider;
+using namespace std;
+
+static int next_download_id = 0;
+
+string const method = "download()";
+
+LocalDownloadJob::LocalDownloadJob(shared_ptr<LocalProvider> const& provider,
+                                   string const& item_id,
+                                   string const& match_etag)
+    : DownloadJob(to_string(++next_download_id))
+    , provider_(provider)
+    , item_id_(item_id)
+{
+    using namespace boost::filesystem;
+
+    // Sanitize parameters.
+    provider_->throw_if_not_valid(method, item_id_);
+    try
+    {
+        auto st = status(item_id_);
+        if (!is_regular_file(st))
+        {
+            throw InvalidArgumentException(method + ": \"" + item_id_ + "\" is not a file");
+        }
+    }
+    // LCOV_EXCL_START  // Too small a window to hit with a test.
+    catch (filesystem_error const& e)
+    {
+        throw_storage_exception(method, e);
+    }
+    // LCOV_EXCL_STOP
+    if (!match_etag.empty())
+    {
+        int64_t mtime = get_mtime_nsecs(method, item_id_);
+        if (to_string(mtime) != match_etag)
+        {
+            throw ConflictException(method + ": etag mismatch");
+        }
+    }
+
+    // Make input file ready.
+    QString filename = QString::fromStdString(item_id);
+    file_.reset(new QFile(filename));
+    if (!file_->open(QIODevice::ReadOnly))
+    {
+        throw_storage_exception(method,
+                                ": cannot open \"" + item_id + "\": " + file_->errorString().toStdString(),
+                                file_->error());
+    }
+    bytes_to_write_ = file_->size();
+
+    // Make write socket ready.
+    int dup_fd = dup(write_socket());
+    if (dup_fd == -1)
+    {
+        // LCOV_EXCL_START
+        string msg = "LocalDownloadJob(): dup() failed: " + unity::storage::internal::safe_strerror(errno);
+        throw ResourceException(msg, errno);
+        // LCOV_EXCL_STOP
+    }
+    write_socket_.setSocketDescriptor(dup_fd, QLocalSocket::ConnectedState, QIODevice::WriteOnly);
+    connect(&write_socket_, &QIODevice::bytesWritten, this, &LocalDownloadJob::on_bytes_written);
+
+    // Kick off the read-write cycle.
+    QMetaObject::invokeMethod(this, "read_and_write_chunk", Qt::QueuedConnection);
+}
+
+LocalDownloadJob::~LocalDownloadJob() = default;
+
+boost::future<void> LocalDownloadJob::cancel()
+{
+    disconnect(&write_socket_, nullptr, this, nullptr);
+    write_socket_.abort();
+    file_->close();
+    return boost::make_ready_future();
+}
+
+boost::future<void> LocalDownloadJob::finish()
+{
+    if (bytes_to_write_ > 0)
+    {
+        auto file_size = file_->size();
+        auto written = file_size - bytes_to_write_;
+        string msg = "finish() method called too early, file \"" + item_id_ + "\" has size "
+                     + to_string(file_size) + " but only " + to_string(written) + " bytes were consumed";
+        cancel();
+        return boost::make_exceptional_future<void>(LogicException(msg));
+    }
+    // LCOV_EXCL_START
+    // Not reachable because we call report_complete() in read_and_write_chunk().
+    return boost::make_ready_future();
+    // LCOV_EXCL_STOP
+}
+
+void LocalDownloadJob::on_bytes_written(qint64 bytes)
+{
+    bytes_to_write_ -= bytes;
+    assert(bytes_to_write_ >= 0);
+    read_and_write_chunk();
+}
+
+void LocalDownloadJob::read_and_write_chunk()
+{
+    static qint64 constexpr READ_SIZE = 64 * 1024;
+
+    if (bytes_to_write_ == 0)
+    {
+        file_->close();
+        write_socket_.close();
+        report_complete();
+        return;
+    }
+
+    QByteArray buf;
+    buf.resize(READ_SIZE);
+    auto bytes_read = file_->read(buf.data(), buf.size());
+    try
+    {
+        if (bytes_read == -1)
+        {
+            // LCOV_EXCL_START
+            string msg = string("\"") + item_id_ + "\": read error: " + file_->errorString().toStdString();
+            throw_storage_exception(method, msg, file_->error());
+            // LCOV_EXCL_STOP
+        }
+        buf.resize(bytes_read);
+
+        auto bytes_written = write_socket_.write(buf);
+        if (bytes_written == -1)
+        {
+            // LCOV_EXCL_START
+            string msg = string("\"") + item_id_ + "\": socket error: " + write_socket_.errorString().toStdString();
+            throw_storage_exception(method, msg, write_socket_.error());
+            // LCOV_EXCL_STOP
+        }
+        else if (bytes_written != bytes_read)
+        {
+            // LCOV_EXCL_START
+            string msg = string("\"") + item_id_ + "\": socket write error, requested " + to_string(bytes_read)
+                         + " B, but wrote only " + to_string(bytes_written) + " B.";
+            throw_storage_exception(method, msg, QLocalSocket::UnknownSocketError);
+            // LCOV_EXCL_STOP
+        }
+    }
+    // LCOV_EXCL_START
+    catch (std::exception const&)
+    {
+        write_socket_.abort();
+        file_->close();
+        report_error(current_exception());
+    }
+    // LCOV_EXCL_STOP
+}

=== added file 'src/local-provider/LocalDownloadJob.h'
--- src/local-provider/LocalDownloadJob.h	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalDownloadJob.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 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/provider/DownloadJob.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#include <QFile>
+#include <QLocalSocket>
+#pragma GCC diagnostic pop
+
+class LocalProvider;
+
+class LocalDownloadJob : public QObject, public unity::storage::provider::DownloadJob
+{
+    Q_OBJECT
+public:
+    LocalDownloadJob(std::shared_ptr<LocalProvider> const& provider,
+                     std::string const& item_id,
+                     std::string const& match_etag);
+    virtual ~LocalDownloadJob();
+
+    virtual boost::future<void> cancel() override;
+    virtual boost::future<void> finish() override;
+
+private Q_SLOTS:
+    void on_bytes_written(qint64 bytes);
+    void read_and_write_chunk();
+
+private:
+    std::shared_ptr<LocalProvider> const provider_;
+    std::string const item_id_;
+    std::unique_ptr<QFile> file_;
+    QLocalSocket write_socket_;
+    int64_t bytes_to_write_;
+};

=== added file 'src/local-provider/LocalProvider.cpp'
--- src/local-provider/LocalProvider.cpp	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalProvider.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,586 @@
+/*
+ * Copyright (C) 2017 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 "LocalProvider.h"
+
+#include "LocalDownloadJob.h"
+#include "LocalUploadJob.h"
+#include "utils.h"
+
+#include <unity/storage/internal/gobj_memory.h>
+#include <unity/storage/provider/Exceptions.h>
+
+#include <boost/algorithm/string.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#include <gio/gio.h>
+#include <glib.h>
+#pragma GCC diagnostic pop
+
+using namespace unity::storage::provider;
+using namespace std;
+
+namespace
+{
+
+// Return the root directory where we store files.
+// If SF_LOCAL_PROVIDER_ROOT is set (used for testing), any files are created
+// directly under the root. E.g., if we do root.createFile("foo.txt", ...), the file
+// will be created as ${SF_LOCAL_PROVIDER_ROOT/foo.txt. SF_LOCAL_PROVIDER_ROOT must
+// be a pre-existing directory.
+//
+// Otherwise, the root is determined by SNAP_USER_COMMON or, if that is not set,
+// by XDG_DATA_HOME. Either way, files are created in a storage-framework/local
+// subdirectory. E.g., if SNAP_USER_COMMON or XDG_DATA_HOME is set to "/tmp" and
+// we do root.createFile("foo.txt", ...), the file will be created as
+// /tmp/storage-framework/local/foo.txt. If /tmp/storage-framework/local does not exist,
+// the directory will be created.
+
+string get_root_dir(string const& method)
+{
+    using namespace boost::filesystem;
+
+    char const* dir = getenv("SF_LOCAL_PROVIDER_ROOT");
+    if (dir && *dir != '\0')
+    {
+        boost::system::error_code ec;
+        if (!exists(dir, ec) || !is_directory(dir, ec))
+        {
+            string msg = method + ": Environment variable SF_LOCAL_PROVIDER_ROOT must denote an existing directory";
+            throw InvalidArgumentException(msg);
+        }
+        return dir;
+    }
+
+    string data_dir;
+    dir = getenv("SNAP_USER_COMMON");
+    if (dir && *dir != '\0')
+    {
+        data_dir = dir;
+    }
+    else
+    {
+        data_dir = g_get_user_data_dir();  // Never fails.
+    }
+    data_dir += "/storage-framework/local";
+
+    try
+    {
+        create_directories(data_dir);
+    }
+    catch (filesystem_error const& e)
+    {
+        throw_storage_exception(method, e);
+    }
+
+    return data_dir;
+}
+
+// Copy a file or directory (recursively). Ignore anything that has the temp file prefix
+// or is not a file or directory.
+
+void copy_recursively(boost::filesystem::path const& source, boost::filesystem::path const& target)
+{
+    using namespace boost::filesystem;
+
+    if (is_reserved_path(source))
+    {
+        return;  // Don't copy temporary directories.
+    }
+
+    auto s = status(source);
+    if (is_regular_file(s))
+    {
+        copy_file(source, target);
+    }
+    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.
+    }
+}
+
+// Convert nanoseconds since the epoch into ISO 8601 date-time.
+
+string make_iso_date(int64_t nsecs_since_epoch)
+{
+    static char const* const FMT = "%Y-%m-%dT%TZ";  // ISO 8601, no fractional seconds.
+
+    struct tm time;
+    time_t secs_since_epoch = nsecs_since_epoch / 1000000000;
+    gmtime_r(&secs_since_epoch, &time);
+
+    char buf[128];
+    strftime(buf, sizeof(buf), FMT, &time);
+    return buf;
+}
+
+string get_content_type(string const& filename)
+{
+    using namespace unity::storage::internal;
+
+    static string const unknown_content_type = "application/octet-stream";
+
+    gobj_ptr<GFile> file(g_file_new_for_path(filename.c_str()));
+    assert(file);  // Cannot fail according to doc.
+
+    GError* err = nullptr;
+    gobj_ptr<GFileInfo> full_info(g_file_query_info(file.get(),
+                                                    G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,
+                                                    G_FILE_QUERY_INFO_NONE,
+                                                    /* cancellable */ NULL,
+                                                    &err));
+    if (!full_info)
+    {
+        return unknown_content_type;  // LCOV_EXCL_LINE
+    }
+
+    string content_type = g_file_info_get_attribute_string(full_info.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE);
+    if (content_type.empty())
+    {
+        return unknown_content_type;  // LCOV_EXCL_LINE
+    }
+    return content_type;
+}
+
+// Simple wrapper template that deals with exception handling so we don't
+// have to repeat ourselves endlessly in the various lambdas below.
+// The auto deduction of the return type requires C++ 14.
+
+template<typename F>
+auto invoke_async(string const& method, F& functor)
+{
+    auto lambda = [method, functor]
+    {
+        try
+        {
+            return functor();
+        }
+        catch (StorageException const&)
+        {
+            throw;
+        }
+        catch (boost::filesystem::filesystem_error const& e)
+        {
+            throw_storage_exception(method, e);
+        }
+        // LCOV_EXCL_START
+        catch (std::exception const& e)
+        {
+            throw boost::enable_current_exception(UnknownException(e.what()));
+        }
+        // LCOV_EXCL_STOP
+    };
+    // TODO: boost::async is potentially expensive for some operations. Consider boost::asio thread pool?
+    return boost::async(boost::launch::async, lambda);
+}
+
+}  // namespace
+
+LocalProvider::LocalProvider()
+    : root_(boost::filesystem::canonical(get_root_dir("LocalProvider()")))
+{
+}
+
+LocalProvider::~LocalProvider() = default;
+
+boost::future<ItemList> LocalProvider::roots(vector<string> const& /* keys */, Context const& /* context */)
+{
+    vector<Item> roots{ make_item("roots()", root_, status(root_)) };
+    return boost::make_ready_future(roots);
+}
+
+boost::future<tuple<ItemList, string>> LocalProvider::list(string const& item_id,
+                                                           string const& page_token,
+                                                           vector<string> const& /* keys */,
+                                                           Context const& /* context */)
+{
+    string const method = "list()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_list = [This, method, item_id, page_token]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, item_id);
+        vector<Item> items;
+        for (directory_iterator it(item_id); it != directory_iterator(); ++it)
+        {
+            auto dirent = *it;
+            auto path = dirent.path();
+            if (is_reserved_path(path))
+            {
+                continue;  // Hide temp files that we create during copy() and move().
+            }
+            Item i;
+            try
+            {
+                auto st = dirent.status();
+                i = This->make_item(method, path, st);
+                items.push_back(i);
+            }
+            catch (std::exception const&)
+            {
+                // We ignore weird errors (such as entries that are not files or folders).
+            }
+        }
+        return tuple<ItemList, string>(items, "");
+    };
+
+    return invoke_async(method, do_list);
+}
+
+boost::future<ItemList> LocalProvider::lookup(string const& parent_id,
+                                              string const& name,
+                                              vector<string> const& /* keys */,
+                                              Context const& /* context */)
+{
+    string const method = "lookup()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_lookup = [This, method, parent_id, name]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, parent_id);
+        auto sanitized_name = sanitize(method, name);
+        path p = parent_id;
+        p /= sanitized_name;
+        This->throw_if_not_valid(method, p.native());
+        auto st = status(p);
+        return vector<Item>{ This->make_item(method, p, st) };
+    };
+
+    return invoke_async(method, do_lookup);
+}
+
+boost::future<Item> LocalProvider::metadata(string const& item_id,
+                                            vector<string> const& /* keys */,
+                                            Context const& /* context */)
+{
+    string const method = "metadata()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_metadata = [This, method, item_id]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, item_id);
+        path p = item_id;
+        auto st = status(p);
+        return This->make_item(method, p, st);
+    };
+
+    return invoke_async(method, do_metadata);
+}
+
+boost::future<Item> LocalProvider::create_folder(string const& parent_id,
+                                                 string const& name,
+                                                 vector<string> const& /* keys */,
+                                                 Context const& /* context */)
+{
+    string const method = "create_folder()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_create = [This, method, parent_id, name]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, parent_id);
+        auto sanitized_name = sanitize(method, name);
+        path p = parent_id;
+        p /= sanitized_name;
+        // create_directory() succeeds if the directory exists already, so we need to check explicitly.
+        if (exists(p))
+        {
+            string msg = method + ": \"" + p.native() + "\" exists already";
+            throw boost::enable_current_exception(ExistsException(msg, p.native(), name));
+        }
+        create_directory(p);
+        auto st = status(p);
+        return This->make_item(method, p, st);
+    };
+
+    return invoke_async(method, do_create);
+}
+
+boost::future<unique_ptr<UploadJob>> LocalProvider::create_file(string const& parent_id,
+                                                                string const& name,
+                                                                int64_t size,
+                                                                string const& /* content_type */,
+                                                                bool allow_overwrite,
+                                                                vector<string> const& /* keys */,
+                                                                Context const& /* context */)
+{
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    boost::promise<unique_ptr<UploadJob>> p;
+    p.set_value(make_unique<LocalUploadJob>(This, parent_id, name, size, allow_overwrite));
+    return p.get_future();
+}
+
+boost::future<unique_ptr<UploadJob>> LocalProvider::update(string const& item_id,
+                                                           int64_t size,
+                                                           string const& old_etag,
+                                                           vector<string> const& /* keys */,
+                                                           Context const& /* context */)
+{
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    boost::promise<unique_ptr<UploadJob>> p;
+    p.set_value(make_unique<LocalUploadJob>(This, item_id, size, old_etag));
+    return p.get_future();
+}
+
+boost::future<unique_ptr<DownloadJob>> LocalProvider::download(string const& item_id,
+                                                               string const& match_etag,
+                                                               Context const& /* context */)
+{
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    boost::promise<unique_ptr<DownloadJob>> p;
+    p.set_value(make_unique<LocalDownloadJob>(This, item_id, match_etag));
+    return p.get_future();
+}
+
+boost::future<void> LocalProvider::delete_item(string const& item_id, Context const& /* context */)
+{
+    string const method = "delete_item()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_delete = [This, method, item_id]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, item_id);
+        if (canonical(item_id).native() == This->root_)
+        {
+            string msg = method + ": cannot delete root";
+            throw boost::enable_current_exception(LogicException(msg));
+        }
+        remove_all(item_id);
+    };
+
+    return invoke_async(method, do_delete);
+}
+
+boost::future<Item> LocalProvider::move(string const& item_id,
+                                        string const& new_parent_id,
+                                        string const& new_name,
+                                        vector<string> const& /* keys */,
+                                        Context const& /* context */)
+{
+    string const method = "move()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_move = [This, method, item_id, new_parent_id, new_name]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, item_id);
+        This->throw_if_not_valid(method, new_parent_id);
+        auto sanitized_name = sanitize(method, new_name);
+
+        path parent_path = new_parent_id;
+        path target_path = parent_path / sanitized_name;
+
+        if (exists(target_path))
+        {
+            string msg = method + ": \"" + target_path.native() + "\" exists already";
+            throw boost::enable_current_exception(ExistsException(msg, target_path.native(), new_name));
+        }
+
+        // Small race condition here: if exists() just said that the target does not exist, it is
+        // possible for it to have been created since. If so, if the target is a file or an empty
+        // directory, it will be removed. In practice, this is unlikely to happen and, if it does,
+        // it is not the end of the world.
+        // TODO: deal with EXDEV
+        rename(item_id, target_path);
+        auto st = status(target_path);
+        return This->make_item(method, target_path, st);
+    };
+
+    return invoke_async(method, do_move);
+}
+
+boost::future<Item> LocalProvider::copy(string const& item_id,
+                                        string const& new_parent_id,
+                                        string const& new_name,
+                                        vector<string> const& /* keys */,
+                                        Context const& /* context */)
+{
+    string const method = "copy()";
+
+    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
+    auto do_copy = [This, method, item_id, new_parent_id, new_name]
+    {
+        using namespace boost::filesystem;
+
+        This->throw_if_not_valid(method, item_id);
+        This->throw_if_not_valid(method, new_parent_id);
+        auto sanitized_name = sanitize(method, new_name);
+
+        path parent_path = new_parent_id;
+        path target_path = parent_path / sanitized_name;
+
+        if (is_directory(item_id))
+        {
+            if (exists(target_path))
+            {
+                string msg = method + ": \"" + target_path.native() + "\" exists already";
+                throw boost::enable_current_exception(ExistsException(msg, target_path.native(), new_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.
+            path tmp_path = canonical(parent_path);
+            tmp_path /= unique_path(string(TMPFILE_PREFIX) + "-%%%%-%%%%-%%%%-%%%%");
+            create_directories(tmp_path);
+            for (directory_iterator it(item_id); it != directory_iterator(); ++it)
+            {
+                if (is_reserved_path(it->path()))
+                {
+                    continue;  // Don't recurse into the temporary directory
+                }
+                file_status s = it->status();
+                if (is_directory(s) || is_regular_file(s))
+                {
+                    path source_entry = it->path();
+                    path target_entry = tmp_path;
+                    target_entry /= source_entry.filename();
+                    copy_recursively(source_entry, target_entry);
+                }
+            }
+            rename(tmp_path, target_path);
+        }
+        else
+        {
+            copy_file(item_id, target_path);
+        }
+
+        auto st = status(target_path);
+        return This->make_item(method, target_path, st);
+    };
+
+    return invoke_async(method, do_copy);
+}
+
+// Make sure that id does not point outside the root.
+
+void LocalProvider::throw_if_not_valid(string const& method, string const& id) const
+{
+    using namespace boost::filesystem;
+
+    string suspect_id;
+    try
+    {
+        suspect_id = canonical(id).native();
+    }
+    catch (filesystem_error const& e)
+    {
+        throw_storage_exception(method, e);
+    }
+
+    // Disallow things such as <root>/blah/../blah even though they lead to the correct path.
+    if (suspect_id != id)
+    {
+        throw boost::enable_current_exception(InvalidArgumentException(method + ": invalid id: \"" + id + "\""));
+    }
+    // id must denote the root or have the root as a prefix.
+    auto const root_id = root_.native();
+    if (id != root_id && !boost::starts_with(id, root_id + "/"))
+    {
+        throw boost::enable_current_exception(InvalidArgumentException(method + ": invalid id: \"" + id + "\""));
+    }
+}
+
+// Return an Item initialized from item_path and st.
+
+Item LocalProvider::make_item(string const& method,
+                              boost::filesystem::path const& item_path,
+                              boost::filesystem::file_status const& st) const
+{
+    using namespace unity::storage;
+    using namespace unity::storage::metadata;
+    using namespace boost::filesystem;
+
+    map<string, MetadataValue> meta;
+
+    string const item_id = item_path.native();
+    int64_t const mtime_nsecs = get_mtime_nsecs(method, item_id);
+    string const iso_mtime = make_iso_date(mtime_nsecs);
+
+    ItemType type;
+    string name = item_path.filename().native();
+    vector<string> parents{item_path.parent_path().native()};
+    string etag;
+    switch (st.type())
+    {
+        case regular_file:
+            type = ItemType::file;
+            etag = to_string(mtime_nsecs);
+            meta.insert({SIZE_IN_BYTES, int64_t(file_size(item_path))});
+            break;
+        case directory_file:
+            if (item_path == root_)
+            {
+                name = "/";
+                parents.clear();
+                type = ItemType::root;
+            }
+            else
+            {
+                type = ItemType::folder;
+            }
+            break;
+        default:
+            throw boost::enable_current_exception(
+                    NotExistsException(method + ": \"" + item_id + "\" is neither a file nor a folder", item_id));
+    }
+
+
+    auto const info = space(item_path);
+    meta.insert({FREE_SPACE_BYTES, int64_t(info.available)});
+    meta.insert({USED_SPACE_BYTES, int64_t(info.capacity - info.available)});
+
+    meta.insert({LAST_MODIFIED_TIME, iso_mtime});
+    meta.insert({CONTENT_TYPE, get_content_type(item_id)});
+
+    auto perms = st.permissions();
+    bool writable;
+    if (type == ItemType::file)
+    {
+        writable = perms & owner_write;
+    }
+    else
+    {
+        writable = perms & owner_write && perms & owner_exe;
+    }
+    meta.insert({WRITABLE, writable});
+
+    return Item{ item_id, parents, name, etag, type, meta };
+}

=== added file 'src/local-provider/LocalProvider.h'
--- src/local-provider/LocalProvider.h	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalProvider.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2017 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/provider/ProviderBase.h>
+
+#include <boost/filesystem.hpp>
+
+class LocalProvider : public unity::storage::provider::ProviderBase
+{
+public:
+    LocalProvider();
+    virtual ~LocalProvider();
+
+    boost::future<unity::storage::provider::ItemList> roots(
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<std::tuple<unity::storage::provider::ItemList, std::string>> list(
+        std::string const& item_id, std::string const& page_token,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<unity::storage::provider::ItemList> lookup(
+        std::string const& parent_id, std::string const& name,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<unity::storage::provider::Item> metadata(
+        std::string const& item_id,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<unity::storage::provider::Item> create_folder(
+        std::string const& parent_id, std::string const& name,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> create_file(
+        std::string const& parent_id, std::string const& name,
+        int64_t size, std::string const& content_type, bool allow_overwrite,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> update(
+        std::string const& item_id, int64_t size,
+        std::string const& old_etag,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<std::unique_ptr<unity::storage::provider::DownloadJob>> download(
+        std::string const& item_id,
+        std::string const& match_etag,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<void> delete_item(std::string const& item_id,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<unity::storage::provider::Item> move(
+        std::string const& item_id, std::string const& new_parent_id,
+        std::string const& new_name,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+    boost::future<unity::storage::provider::Item> copy(
+        std::string const& item_id, std::string const& new_parent_id,
+        std::string const& new_name,
+        std::vector<std::string> const& metadata_keys,
+        unity::storage::provider::Context const& ctx) override;
+
+    void throw_if_not_valid(std::string const& method, std::string const& id) const;
+    unity::storage::provider::Item make_item(std::string const& method,
+                                             boost::filesystem::path const& item_path,
+                                             boost::filesystem::file_status const& st) const;
+
+private:
+    boost::filesystem::path const root_;
+};

=== added file 'src/local-provider/LocalUploadJob.cpp'
--- src/local-provider/LocalUploadJob.cpp	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalUploadJob.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,337 @@
+/*
+ * Copyright (C) 2017 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 "LocalUploadJob.h"
+
+#include "LocalProvider.h"
+#include "utils.h"
+#include <unity/storage/internal/safe_strerror.h>
+#include <unity/storage/provider/Exceptions.h>
+
+#include <fcntl.h>
+
+using namespace unity::storage::provider;
+using namespace std;
+
+static int next_upload_id = 0;
+
+LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider, int64_t size, const string& method)
+    : UploadJob(to_string(++next_upload_id))
+    , provider_(provider)
+    , size_(size)
+    , bytes_to_write_(size)
+    , method_(method)
+    , state_(in_progress)
+    , tmp_fd_([](int fd){ if (fd != -1) ::close(fd); })
+{
+}
+
+LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider,
+                               string const& parent_id,
+                               string const& name,
+                               int64_t size,
+                               bool allow_overwrite)
+    : LocalUploadJob(provider, size, "create_file()")
+{
+    using namespace boost::filesystem;
+
+    parent_id_ = parent_id;
+    allow_overwrite_ = allow_overwrite;
+
+    provider_->throw_if_not_valid(method_, parent_id);
+
+    auto sanitized_name = sanitize(method_, name);
+    path p = parent_id;
+    p /= sanitized_name;
+    item_id_ = p.native();
+    if (!allow_overwrite && exists(item_id_))
+    {
+        string msg = method_ + ": \"" + item_id_ + "\" exists already";
+        throw ExistsException(msg, item_id_, sanitized_name.native());
+    }
+
+    prepare_channels();
+}
+
+LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider,
+                               string const& item_id,
+                               int64_t size,
+                               string const& old_etag)
+    : LocalUploadJob(provider, size, "update()")
+{
+    using namespace boost::filesystem;
+
+    item_id_ = item_id;
+    provider_->throw_if_not_valid(method_, item_id);
+    try
+    {
+        auto st = status(item_id);
+        if (!is_regular_file(st))
+        {
+            throw InvalidArgumentException(method_ + ": \"" + item_id + "\" is not a file");
+        }
+    }
+    // LCOV_EXCL_START
+    catch (filesystem_error const& e)
+    {
+        // The call to status could throw if the file is unlinked immediately
+        // after the call to throw_if_not_valid.
+        throw_storage_exception(method_, e);
+    }
+    // LCOV_EXCL_STOP
+    if (!old_etag.empty())
+    {
+        int64_t mtime = get_mtime_nsecs(method_, item_id);
+        if (to_string(mtime) != old_etag)
+        {
+            throw ConflictException(method_ + ": etag mismatch");
+        }
+    }
+    old_etag_ = old_etag;
+
+    prepare_channels();
+}
+
+LocalUploadJob::~LocalUploadJob() = default;
+
+void LocalUploadJob::prepare_channels()
+{
+    using namespace boost::filesystem;
+
+    // Open tmp file for writing.
+    auto parent_path = path(item_id_).parent_path();
+    tmp_fd_.reset(open(parent_path.native().c_str(), O_TMPFILE | O_WRONLY, 0600));
+    if (tmp_fd_.get() == -1)
+    {
+        // Some kernels on the phones don't support O_TMPFILE and return various errno values when this fails.
+        // So, if anything at all goes wrong, we fall back on conventional temp file creation and
+        // produce a hard error if that doesn't work either.
+        // Note that, in this case, the temp file retains its name in the file system. Not nice because,
+        // if this process dies at the wrong moment, we leave the temp file behind.
+        use_linkat_ = false;
+        string tmpfile = parent_path.native() + "/" + TMPFILE_PREFIX + "-%%%%-%%%%-%%%%-%%%%";
+        tmp_fd_.reset(mkstemp(const_cast<char*>(tmpfile.data())));
+        if (tmp_fd_.get() == -1)
+        {
+            string msg = method_ + ": cannot create temp file \"" + tmpfile + "\": "
+                         + unity::storage::internal::safe_strerror(errno);
+            throw ResourceException(msg, errno);
+        }
+        // LCOV_EXCL_START
+        file_.reset(new QFile(QString::fromStdString(tmpfile)));
+        file_->open(QIODevice::WriteOnly);
+        // LCOV_EXCL_STOP
+    }
+    else
+    {
+        use_linkat_ = true;
+        file_.reset(new QFile);
+        file_->open(tmp_fd_.get(), QIODevice::WriteOnly, QFileDevice::DontCloseHandle);
+    }
+
+    // Make read socket ready.
+    int dup_fd = dup(read_socket());
+    if (dup_fd == -1)
+    {
+        // LCOV_EXCL_START
+        string msg = method_ + ": dup() failed: " + unity::storage::internal::safe_strerror(errno);
+        throw ResourceException(msg, errno);
+        // LCOV_EXCL_STOP
+    }
+    read_socket_.setSocketDescriptor(dup_fd, QLocalSocket::ConnectedState, QIODevice::ReadOnly);
+    connect(&read_socket_, &QLocalSocket::readyRead, this, &LocalUploadJob::on_bytes_ready);
+    connect(&read_socket_, &QIODevice::readChannelFinished, this, &LocalUploadJob::on_read_channel_finished);
+}
+
+boost::future<void> LocalUploadJob::cancel()
+{
+    if (state_ == in_progress)
+    {
+        abort_upload();
+    }
+    return boost::make_ready_future();
+}
+
+boost::future<Item> LocalUploadJob::finish()
+{
+    on_bytes_ready();  // Read any remaining unread buffered data.
+
+    if (bytes_to_write_ > 0)
+    {
+        string msg = "finish() method called too early, size was given as "
+                     + to_string(size_) + " but only "
+                     + to_string(size_ - bytes_to_write_) + " bytes were received";
+        return boost::make_exceptional_future<Item>(LogicException(msg));
+    }
+
+    // We are committed to finishing successfully or with an error now.
+    state_ = finished;
+
+    try
+    {
+        // We check again for an etag mismatch or overwrite, in case the file was updated after the upload started.
+        if (!parent_id_.empty())
+        {
+            // create_file()
+            if (!allow_overwrite_ && boost::filesystem::exists(item_id_))
+            {
+                string msg = method_ + ": \"" + item_id_ + "\" exists already";
+                boost::filesystem::path(item_id_).filename().native();
+                BOOST_THROW_EXCEPTION(
+                    ExistsException(msg, item_id_, boost::filesystem::path(item_id_).filename().native()));
+            }
+        }
+        else if (!old_etag_.empty())
+        {
+            // update()
+            int64_t mtime = get_mtime_nsecs(method_, item_id_);
+            if (to_string(mtime) != old_etag_)
+            {
+                BOOST_THROW_EXCEPTION(ConflictException(method_ + ": etag mismatch"));
+            }
+        }
+
+        if (!file_->flush())  // Make sure that all buffered data is written.
+        {
+            // LCOV_EXCL_START
+            string msg = "finish(): cannot flush output file: " + file_->errorString().toStdString();
+            throw_storage_exception("finish()", msg, file_->error());
+            // LCOV_EXCL_STOP
+        }
+
+        // Link the anonymous tmp file into the file system.
+        using namespace unity::storage::internal;
+
+        if (use_linkat_)
+        {
+            auto old_path = string("/proc/self/fd/") + std::to_string(tmp_fd_.get());
+            ::unlink(item_id_.c_str());  // linkat() will not remove existing file: http://lwn.net/Articles/559969/
+            if (linkat(-1, old_path.c_str(), tmp_fd_.get(), item_id_.c_str(), AT_SYMLINK_FOLLOW) == -1)
+            {
+                // LCOV_EXCL_START
+                string msg = "finish(): linkat \"" + old_path + "\" to \"" + item_id_ + "\" failed: "
+                             + safe_strerror(errno);
+                BOOST_THROW_EXCEPTION(ResourceException(msg, errno));
+                // LCOV_EXCL_STOP
+            }
+        }
+        else
+        {
+            // LCOV_EXCL_START
+            auto old_path = file_->fileName().toStdString();
+            if (rename(old_path.c_str(), item_id_.c_str()) == -1)
+            {
+                string msg = "finish(): rename \"" + old_path + "\" to \"" + item_id_ + "\" failed: "
+                             + safe_strerror(errno);
+                BOOST_THROW_EXCEPTION(ResourceException(msg, errno));
+            }
+            // LCOV_EXCL_STOP
+        }
+
+        file_->close();
+        read_socket_.close();
+
+        auto st = boost::filesystem::status(item_id_);
+        return boost::make_ready_future<Item>(provider_->make_item(method_, item_id_, st));
+    }
+    catch (StorageException const&)
+    {
+        return boost::make_exceptional_future<Item>(boost::current_exception());
+    }
+    // LCOV_EXCL_START
+    catch (boost::filesystem::filesystem_error const& e)
+    {
+        try
+        {
+            throw_storage_exception("finish()", e);
+        }
+        catch (StorageException const&)
+        {
+            return boost::make_exceptional_future<Item>(boost::current_exception());
+        }
+    }
+    catch (std::exception const& e)
+    {
+        return boost::make_exceptional_future<Item>(UnknownException(e.what()));
+    }
+    // LCOV_EXCL_STOP
+}
+
+void LocalUploadJob::on_bytes_ready()
+{
+    if (bytes_to_write_ < 0)
+    {
+        return;  // LCOV_EXCL_LINE  // We received too many bytes earlier.
+    }
+
+    try
+    {
+        auto buf = read_socket_.readAll();
+        if (buf.size() != 0)
+        {
+            bytes_to_write_ -= buf.size();
+            if (bytes_to_write_ < 0)
+            {
+                string msg = method_ + ": received more than the expected number (" + to_string(size_) + ") of bytes";
+                throw LogicException(msg);
+            }
+            auto bytes_written = file_->write(buf);
+            if (bytes_written == -1)
+            {
+                // LCOV_EXCL_START
+                string msg = "write error: " + file_->errorString().toStdString();
+                throw_storage_exception(method_, msg, file_->error());
+                // LCOV_EXCL_STOP
+            }
+            else if (bytes_written != buf.size())
+            {
+                // LCOV_EXCL_START
+                string msg = "write error, requested " + to_string(buf.size()) + " B, but wrote only "
+                             + to_string(bytes_written) + " B.";
+                throw_storage_exception(method_, msg, QFileDevice::FatalError);
+                // LCOV_EXCL_STOP
+            }
+        }
+    }
+    catch (std::exception const&)
+    {
+        abort_upload();
+        report_error(current_exception());
+    }
+}
+
+void LocalUploadJob::on_read_channel_finished()
+{
+    on_bytes_ready();  // In case there s still buffered data to be read.
+}
+
+void LocalUploadJob::abort_upload()
+{
+    state_ = cancelled;
+    disconnect(&read_socket_, nullptr, this, nullptr);
+    read_socket_.abort();
+    file_->close();
+    if (!use_linkat_)
+    {
+        // LCOV_EXCL_START
+        string filename = file_->fileName().toStdString();
+        ::unlink(filename.c_str());  // Don't leave any temp file behind.
+        // LCOV_EXCL_STOP
+    }
+    bytes_to_write_ = 0;
+}

=== added file 'src/local-provider/LocalUploadJob.h'
--- src/local-provider/LocalUploadJob.h	1970-01-01 00:00:00 +0000
+++ src/local-provider/LocalUploadJob.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2017 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/provider/UploadJob.h>
+
+#include <unity/util/ResourcePtr.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#include <QFile>
+#include <QLocalSocket>
+#pragma GCC diagnostic pop
+
+class LocalProvider;
+
+class LocalUploadJob : public QObject, public unity::storage::provider::UploadJob
+{
+    Q_OBJECT
+public:
+    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider, int64_t size, const std::string& method);
+
+    // create_file()
+    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider,
+                   std::string const& parent_id,
+                   std::string const& name,
+                   int64_t size,
+                   bool allow_overwrite);
+    // update()
+    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider,
+                   std::string const& item_id,
+                   int64_t size,
+                   std::string const& old_etag);
+    virtual ~LocalUploadJob();
+
+    virtual boost::future<void> cancel() override;
+    virtual boost::future<unity::storage::provider::Item> finish() override;
+
+private Q_SLOTS:
+    void on_bytes_ready();
+    void on_read_channel_finished();
+
+private:
+    enum State { in_progress, finished, cancelled };
+
+    void prepare_channels();
+    void abort_upload();
+
+    std::shared_ptr<LocalProvider> const provider_;
+    int64_t const size_;
+    int64_t bytes_to_write_;
+    std::unique_ptr<QFile> file_;
+    QLocalSocket read_socket_;
+    std::string const method_;
+    State state_;
+    std::string item_id_;
+    std::string old_etag_;   // Empty for create_file()
+    std::string parent_id_;  // Empty for update()
+    bool allow_overwrite_;   // Undefined for update()
+    unity::util::ResourcePtr<int, std::function<void(int)>> tmp_fd_;
+    bool use_linkat_;
+};

=== added file 'src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in'
--- src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in	1970-01-01 00:00:00 +0000
+++ src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in	2017-03-20 04:58:30 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.StorageFramework.Provider.Local
+Exec=@CMAKE_INSTALL_FULL_LIBDIR@/@PROJECT_NAME@/storage-provider-local

=== added file 'src/local-provider/main.cpp'
--- src/local-provider/main.cpp	1970-01-01 00:00:00 +0000
+++ src/local-provider/main.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2017 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/Server.h>
+
+#include "LocalProvider.h"
+
+#include <boost/filesystem.hpp>
+
+#include <iostream>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+int main(int argc, char* argv[])
+{
+    using namespace boost::filesystem;
+
+    string const bus_name = "com.canonical.StorageFramework.Provider.Local";
+    string const account_service_id = "";
+
+    string progname = argv[0];
+
+    try
+    {
+        progname = path(progname).filename().native();
+
+        Server<LocalProvider> server(bus_name, account_service_id);
+        server.init(argc, argv);
+        server.run();
+    }
+    catch (std::exception const& e)
+    {
+        cerr << progname << ": " << e.what() << endl;
+        return 1;
+    }
+}

=== added file 'src/local-provider/utils.cpp'
--- src/local-provider/utils.cpp	1970-01-01 00:00:00 +0000
+++ src/local-provider/utils.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2017 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 "utils.h"
+
+#include <unity/storage/internal/safe_strerror.h>
+#include <unity/storage/provider/Exceptions.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/exception/enable_current_exception.hpp>
+
+#include <sys/stat.h>
+
+using namespace unity::storage::provider;
+using namespace std;
+
+// Return modification time in nanoseconds since the epoch.
+
+int64_t get_mtime_nsecs(string const& method, string const& path)
+{
+    using namespace unity::storage::internal;
+
+    struct stat st;
+    if (stat(path.c_str(), &st) == -1)
+    {
+        // LCOV_EXCL_START
+        string msg = method + ": cannot stat \"" + path + "\": " + safe_strerror(errno);
+        throw boost::enable_current_exception(ResourceException(msg, errno));
+        // LCOV_EXCL_STOP
+    }
+    return int64_t(st.st_mtim.tv_sec) * 1000000000 + st.st_mtim.tv_nsec;
+}
+
+// Return true if the path uses the temp file prefix.
+
+bool is_reserved_path(boost::filesystem::path const& path)
+{
+    string filename = path.filename().native();
+    return boost::starts_with(filename, TMPFILE_PREFIX);
+}
+
+// Check that name is a valid file or directory name, that is, has a single component
+// and is not "", ".", or "..". Also check that the name does not start with the
+// temp file prefix. Throw if the name is invalid.
+
+boost::filesystem::path sanitize(string const& method, string const& name)
+{
+    using namespace boost::filesystem;
+
+    path p = name;
+    if (!p.parent_path().empty())
+    {
+        // name contains more than one component.
+        string msg = method + ": name \"" + name + "\" cannot contain a slash";
+        throw boost::enable_current_exception(InvalidArgumentException(msg));
+    }
+    path filename = p.filename();
+    if (filename.empty() || filename == "." || filename == "..")
+    {
+        // Not an allowable file name.
+        string msg = method + ": invalid name: \"" + name + "\"";
+        throw boost::enable_current_exception(InvalidArgumentException(msg));
+    }
+    if (is_reserved_path(filename))
+    {
+        string msg = string(method + ": names beginning with \"") + TMPFILE_PREFIX + "\" are reserved";
+        throw boost::enable_current_exception(InvalidArgumentException(msg));
+    }
+    return p;
+}
+
+// Throw a StorageException that corresponds to a boost::filesystem_error.
+
+void throw_storage_exception(string const& method, boost::filesystem::filesystem_error const& e)
+{
+    using namespace boost::system::errc;
+
+    string msg = method + ": ";
+    string path1 = e.path1().native();
+    string path2 = e.path2().native();
+    if (!path2.empty())
+    {
+        msg += "src = \"" + path1 + "\", target = \"" + path2 + "\"";  // LCOV_EXCL_LINE
+    }
+    else
+    {
+        msg += "\"" + path1 + "\"";
+    }
+    msg += string(": ") + e.what();
+    switch (e.code().value())
+    {
+        case permission_denied:
+        case operation_not_permitted:
+            throw boost::enable_current_exception(PermissionException(msg));
+        case no_such_file_or_directory:
+            throw boost::enable_current_exception(NotExistsException(msg, e.path1().native()));
+        // LCOV_EXCL_START
+        case file_exists:
+            throw boost::enable_current_exception(
+                    ExistsException(msg, e.path1().native(), e.path1().filename().native()));
+        case no_space_on_device:
+            throw boost::enable_current_exception(QuotaException(msg));
+        default:
+            throw boost::enable_current_exception(ResourceException(msg, e.code().value()));
+        // LCOV_EXCL_STOP
+    }
+}
+
+// Throw a storage exception that corresponds to a FileError.
+
+void throw_storage_exception(string const& method, string const& msg, QFileDevice::FileError e)
+{
+    string const error_msg = method + ": " + msg;
+    switch (e)
+    {
+        case QFileDevice::NoError:
+            abort();  // LCOV_EXCL_LINE  // Precondition violation
+            break;
+        default:
+            throw ResourceException(error_msg + " (QFileDevice::FileError = " + to_string(e) + ")", e);
+    }
+}
+
+// Throw a storage exception that corresponds to a LocalSocketError.
+
+// LCOV_EXCL_START
+void throw_storage_exception(string const& method, string const& msg, QLocalSocket::LocalSocketError e)
+{
+    throw ResourceException(method + ": " + msg + " (QLocalSocket::LocalSocketError = " + to_string(e) + ")", e);
+}
+// LCOV_EXCL_STOP

=== added file 'src/local-provider/utils.h'
--- src/local-provider/utils.h	1970-01-01 00:00:00 +0000
+++ src/local-provider/utils.h	2017-03-20 04:58:30 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2017 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 <boost/filesystem.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+#include <QFileDevice>
+#include <QLocalSocket>
+#include <QString>
+#pragma GCC diagnostic pop
+
+#include <string>
+
+constexpr char const* TMPFILE_PREFIX = ".storage-framework";
+
+int64_t get_mtime_nsecs(std::string const& method, std::string const& path);
+bool is_reserved_path(boost::filesystem::path const& path);
+boost::filesystem::path sanitize(std::string const& method, std::string const& name);
+
+[[ noreturn ]]
+void throw_storage_exception(std::string const& method, boost::filesystem::filesystem_error const& e);
+
+[[ noreturn ]]
+void throw_storage_exception(std::string const& method, std::string const& msg, QFileDevice::FileError e);
+
+[[ noreturn ]]
+void throw_storage_exception(std::string const& method, std::string const& msg, QLocalSocket::LocalSocketError e);

=== modified file 'src/provider/CMakeLists.txt'
--- src/provider/CMakeLists.txt	2016-10-12 08:08:48 +0000
+++ src/provider/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -23,8 +23,10 @@
   internal/AccountData.cpp
   internal/DBusPeerCache.cpp
   internal/DownloadJobImpl.cpp
+  internal/FixedAccountData.cpp
   internal/Handler.cpp
   internal/MainLoopExecutor.cpp
+  internal/OnlineAccountData.cpp
   internal/PendingJobs.cpp
   internal/ProviderInterface.cpp
   internal/ServerImpl.cpp
@@ -34,8 +36,10 @@
   internal/dbusmarshal.cpp
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/AccountData.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/DownloadJobImpl.h
+  ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/FixedAccountData.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/Handler.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/MainLoopExecutor.h
+  ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/OnlineAccountData.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/PendingJobs.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/ProviderInterface.h
   ${CMAKE_SOURCE_DIR}/include/unity/storage/provider/internal/ServerImpl.h

=== modified file 'src/provider/Exceptions.cpp'
--- src/provider/Exceptions.cpp	2016-08-05 05:37:23 +0000
+++ src/provider/Exceptions.cpp	2017-03-20 04:58:30 +0000
@@ -97,6 +97,13 @@
 
 ConflictException::~ConflictException() = default;
 
+UnauthorizedException::UnauthorizedException(string const& error_message)
+    : StorageException("UnauthorizedException", error_message)
+{
+}
+
+UnauthorizedException::~UnauthorizedException() = default;
+
 PermissionException::PermissionException(string const& error_message)
     : StorageException("PermissionException", error_message)
 {

=== modified file 'src/provider/Server.cpp'
--- src/provider/Server.cpp	2016-07-12 02:22:05 +0000
+++ src/provider/Server.cpp	2017-03-20 04:58:30 +0000
@@ -42,9 +42,9 @@
     p_->init(argc, argv);
 }
 
-void ServerBase::run()
+int ServerBase::run()
 {
-    p_->run();
+    return p_->run();
 }
 
 }

=== modified file 'src/provider/internal/AccountData.cpp'
--- src/provider/internal/AccountData.cpp	2016-09-28 11:58:35 +0000
+++ src/provider/internal/AccountData.cpp	2017-03-20 04:58:30 +0000
@@ -17,14 +17,15 @@
  */
 
 #include <unity/storage/provider/internal/AccountData.h>
+#include <unity/storage/internal/InactivityTimer.h>
 #include <unity/storage/provider/ProviderBase.h>
 #include <unity/storage/provider/internal/DBusPeerCache.h>
 #include <unity/storage/provider/internal/PendingJobs.h>
 
-#include <OnlineAccounts/AuthenticationData>
 #include <QDebug>
 
 using namespace std;
+using unity::storage::internal::InactivityTimer;
 
 namespace unity {
 namespace storage {
@@ -33,13 +34,12 @@
 
 AccountData::AccountData(shared_ptr<ProviderBase> const& provider,
                          shared_ptr<DBusPeerCache> const& dbus_peer,
+                         shared_ptr<InactivityTimer> const& inactivity_timer,
                          QDBusConnection const& bus,
-                         OnlineAccounts::Account* account,
                          QObject* parent)
     : QObject(parent), provider_(provider), dbus_peer_(dbus_peer),
-      jobs_(new PendingJobs(bus)), account_(account)
+      inactivity_timer_(inactivity_timer), jobs_(new PendingJobs(bus))
 {
-    authenticate(false);
 }
 
 AccountData::~AccountData() = default;
@@ -54,121 +54,16 @@
     return *dbus_peer_;
 }
 
+shared_ptr<InactivityTimer> AccountData::inactivity_timer()
+{
+    return inactivity_timer_;
+}
+
 PendingJobs& AccountData::jobs()
 {
     return *jobs_;
 }
 
-void AccountData::authenticate(bool interactive)
-{
-    // If there is an existing authenticating session running, use
-    // that existing session (unless it is a non-interactive session
-    // and we've requested interactivity).
-    if (auth_watcher_ && (authenticating_interactively_ || !interactive))
-    {
-        return;
-    }
-
-    authenticating_interactively_ = interactive;
-    credentials_valid_ = false;
-    credentials_ = boost::blank();
-
-    OnlineAccounts::AuthenticationData auth_data(
-        account_->authenticationMethod());
-    auth_data.setInteractive(interactive);
-    OnlineAccounts::PendingCall call = account_->authenticate(auth_data);
-    auth_watcher_.reset(new OnlineAccounts::PendingCallWatcher(call));
-    connect(auth_watcher_.get(), &OnlineAccounts::PendingCallWatcher::finished,
-            this, &AccountData::on_authenticated);
-}
-
-bool AccountData::has_credentials()
-{
-    return credentials_valid_;
-}
-
-Credentials const& AccountData::credentials()
-{
-    return credentials_;
-}
-
-void AccountData::on_authenticated()
-{
-    credentials_ = boost::blank();
-    credentials_valid_ = true;
-    switch (account_->authenticationMethod()) {
-    case OnlineAccounts::AuthenticationMethodOAuth1:
-    {
-        OnlineAccounts::OAuth1Reply reply(*auth_watcher_);
-        if (reply.hasError())
-        {
-            qDebug() << "Failed to authenticate:" << reply.error().text();
-        }
-        else
-        {
-            credentials_ = OAuth1Credentials{
-                reply.consumerKey().toStdString(),
-                reply.consumerSecret().toStdString(),
-                reply.token().toStdString(),
-                reply.tokenSecret().toStdString(),
-            };
-        }
-        break;
-    }
-    case OnlineAccounts::AuthenticationMethodOAuth2:
-    {
-        OnlineAccounts::OAuth2Reply reply(*auth_watcher_);
-        if (reply.hasError())
-        {
-            qDebug() << "Failed to authenticate:" << reply.error().text();
-        }
-        else
-        {
-            credentials_ = OAuth2Credentials{
-                reply.accessToken().toStdString(),
-            };
-        }
-        break;
-    }
-    case OnlineAccounts::AuthenticationMethodPassword:
-    {
-        // Grab hostname from account settings if available
-        string host = account_->setting("host").toString().toStdString();
-
-        OnlineAccounts::PasswordReply reply(*auth_watcher_);
-        if (reply.hasError())
-        {
-            qDebug() << "Failed to authenticate:" << reply.error().text();
-        }
-        else
-        {
-            QString username = reply.username();
-            QString password = reply.password();
-
-            // Work around password credentials bug in online-accounts-service
-            //   https://bugs.launchpad.net/bugs/1628473
-            if (username.isEmpty() && password.isEmpty())
-            {
-                username = reply.data()["UserName"].toString();
-                password = reply.data()["Secret"].toString();
-            }
-            credentials_ = PasswordCredentials{
-                username.toStdString(),
-                password.toStdString(),
-                move(host),
-            };
-        }
-        break;
-    }
-    default:
-        qDebug() << "Unhandled authentication method:"
-                 << account_->authenticationMethod();
-    }
-    auth_watcher_.reset();
-
-    Q_EMIT authenticated();
-}
-
 }
 }
 }

=== modified file 'src/provider/internal/DownloadJobImpl.cpp'
--- src/provider/internal/DownloadJobImpl.cpp	2016-09-02 13:51:37 +0000
+++ src/provider/internal/DownloadJobImpl.cpp	2017-03-20 04:58:30 +0000
@@ -105,6 +105,11 @@
     return sock;
 }
 
+void DownloadJobImpl::set_activity(std::shared_ptr<InactivityTimer> const& inactivity_timer)
+{
+    activity_ = ActivityNotifier(inactivity_timer);
+}
+
 void DownloadJobImpl::report_complete()
 {
     if (write_socket_ >= 0)

=== added file 'src/provider/internal/FixedAccountData.cpp'
--- src/provider/internal/FixedAccountData.cpp	1970-01-01 00:00:00 +0000
+++ src/provider/internal/FixedAccountData.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2017 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/FixedAccountData.h>
+
+using namespace std;
+using unity::storage::internal::InactivityTimer;
+
+namespace unity {
+namespace storage {
+namespace provider {
+namespace internal {
+
+FixedAccountData::FixedAccountData(shared_ptr<ProviderBase> const& provider,
+                                     shared_ptr<DBusPeerCache> const& dbus_peer,
+                                     shared_ptr<InactivityTimer> const& inactivity_timer,
+                                     QDBusConnection const& bus,
+                                     QObject* parent)
+    : AccountData(provider, dbus_peer, inactivity_timer, bus, parent)
+{
+}
+
+FixedAccountData::~FixedAccountData() = default;
+
+void FixedAccountData::authenticate(bool interactive, bool invalidate_cache)
+{
+    Q_UNUSED(interactive);
+    Q_UNUSED(invalidate_cache);
+
+    // Queue an emission of the authenticated signal.
+    QMetaObject::invokeMethod(this, "authenticated", Qt::QueuedConnection);
+}
+
+bool FixedAccountData::has_credentials()
+{
+    return true;
+}
+
+Credentials const& FixedAccountData::credentials()
+{
+    return credentials_;
+}
+
+}
+}
+}
+}

=== modified file 'src/provider/internal/Handler.cpp'
--- src/provider/internal/Handler.cpp	2016-10-12 05:25:20 +0000
+++ src/provider/internal/Handler.cpp	2017-03-20 04:58:30 +0000
@@ -49,12 +49,42 @@
 Handler::Handler(shared_ptr<AccountData> const& account,
                  Callback const& callback,
                  QDBusConnection const& bus, QDBusMessage const& message)
-    : account_(account), callback_(callback), bus_(bus), message_(message)
+    : account_(account), callback_(callback), bus_(bus), message_(message),
+      activity_(account->inactivity_timer())
 {
 }
 
 void Handler::begin()
 {
+    // If we have already retrieved credentials from OnlineAccounts,
+    // and we aren't retrying the request, go to on_authenticated
+    // immediately.
+    if (account_->has_credentials() && !retry_)
+    {
+        on_authenticated();
+        return;
+    }
+
+    // Otherwise, try to authenticate and wait for the result.
+    account_->authenticate(true, retry_);
+    connect(account_.get(), &AccountData::authenticated,
+            this, &Handler::on_authenticated);
+}
+
+void Handler::on_authenticated()
+{
+    disconnect(account_.get(), &AccountData::authenticated,
+               this, &Handler::on_authenticated);
+    if (!account_->has_credentials())
+    {
+        string msg = "Handler::begin(): could not retrieve account credentials";
+        qDebug() << QString::fromStdString(msg);
+        auto ep = make_exception_ptr(UnauthorizedException(msg));
+        marshal_exception(ep);
+        QMetaObject::invokeMethod(this, "send_reply", Qt::QueuedConnection);
+        return;
+    }
+
     // Need to put security check in here.
     auto peer_future = account_->dbus_peer().get(message_.service());
     creds_future_ = peer_future.then(
@@ -71,9 +101,9 @@
             }
             else
             {
-                string msg = "Handler::begin(): could not retrieve credentials";
+                string msg = "Handler::begin(): could not retrieve D-Bus peer credentials";
                 qDebug() << QString::fromStdString(msg);
-                auto ep = make_exception_ptr(PermissionException(msg));
+                auto ep = make_exception_ptr(UnauthorizedException(msg));
                 marshal_exception(ep);
                 QMetaObject::invokeMethod(this, "send_reply",
                                           Qt::QueuedConnection);
@@ -103,6 +133,13 @@
             {
                 reply_ = f.get();
             }
+            catch (UnauthorizedException const& e)
+            {
+                QMetaObject::invokeMethod(this, "handle_unauthorized",
+                                          Qt::QueuedConnection,
+                                          Q_ARG(std::exception_ptr, current_exception()));
+                return;
+            }
             catch (std::exception const& e)
             {
                 marshal_exception(current_exception());
@@ -111,6 +148,22 @@
         });
 }
 
+void Handler::handle_unauthorized(exception_ptr ep)
+{
+    if (retry_)
+    {
+        // We've already retried once, so send error out as is.
+        marshal_exception(ep);
+        send_reply();
+    }
+    else
+    {
+        // Otherwise, restart the request with the retry_ flag set.
+        retry_ = true;
+        begin();
+    }
+}
+
 void Handler::send_reply()
 {
     bus_.send(reply_);

=== added file 'src/provider/internal/OnlineAccountData.cpp'
--- src/provider/internal/OnlineAccountData.cpp	1970-01-01 00:00:00 +0000
+++ src/provider/internal/OnlineAccountData.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2017 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/OnlineAccountData.h>
+
+#include <OnlineAccounts/AuthenticationData>
+#include <QDebug>
+
+using namespace std;
+using unity::storage::internal::InactivityTimer;
+
+namespace unity {
+namespace storage {
+namespace provider {
+namespace internal {
+
+OnlineAccountData::OnlineAccountData(shared_ptr<ProviderBase> const& provider,
+                                     shared_ptr<DBusPeerCache> const& dbus_peer,
+                                     shared_ptr<InactivityTimer> const& inactivity_timer,
+                                     QDBusConnection const& bus,
+                                     OnlineAccounts::Account* account,
+                                     QObject* parent)
+    : AccountData(provider, dbus_peer, inactivity_timer, bus, parent),
+      account_(account)
+{
+    connect(account_, &OnlineAccounts::Account::changed,
+            this, &OnlineAccountData::on_changed);
+    authenticate(false);
+}
+
+OnlineAccountData::~OnlineAccountData() = default;
+
+void OnlineAccountData::authenticate(bool interactive, bool invalidate_cache)
+{
+    // If there is an existing authentication session running, check
+    // if it matches our requirements.
+    if (auth_watcher_)
+    {
+        if (invalidate_cache)
+        {
+            // If invalidate_cache has been requested, the existing
+            // session must also be invalidating the cache.
+            if (authenticating_invalidate_cache_)
+            {
+                return;
+            }
+        }
+        else if (interactive)
+        {
+            // If interactive has been requested, the existing session
+            // must also be interactive.
+            if (authenticating_interactively_)
+            {
+                return;
+            }
+        }
+        else
+        {
+            // Otherwise, any session will do.
+            return;
+        }
+    }
+
+    authenticating_interactively_ = interactive;
+    authenticating_invalidate_cache_ = invalidate_cache;
+    credentials_ = boost::blank();
+
+    OnlineAccounts::AuthenticationData auth_data(
+        account_->authenticationMethod());
+    auth_data.setInteractive(interactive);
+    if (invalidate_cache)
+    {
+        auth_data.invalidateCachedReply();
+    }
+    OnlineAccounts::PendingCall call = account_->authenticate(auth_data);
+    auth_watcher_.reset(new OnlineAccounts::PendingCallWatcher(call));
+    connect(auth_watcher_.get(), &OnlineAccounts::PendingCallWatcher::finished,
+            this, &OnlineAccountData::on_authenticated);
+}
+
+bool OnlineAccountData::has_credentials()
+{
+    // variant index 0 is boost::blank
+    return credentials_.which() != 0;
+}
+
+Credentials const& OnlineAccountData::credentials()
+{
+    return credentials_;
+}
+
+void OnlineAccountData::on_authenticated()
+{
+    credentials_ = boost::blank();
+    switch (account_->authenticationMethod()) {
+    case OnlineAccounts::AuthenticationMethodOAuth1:
+    {
+        OnlineAccounts::OAuth1Reply reply(*auth_watcher_);
+        if (reply.hasError())
+        {
+            qDebug() << "Failed to authenticate:" << reply.error().text();
+        }
+        else
+        {
+            credentials_ = OAuth1Credentials{
+                reply.consumerKey().toStdString(),
+                reply.consumerSecret().toStdString(),
+                reply.token().toStdString(),
+                reply.tokenSecret().toStdString(),
+            };
+        }
+        break;
+    }
+    case OnlineAccounts::AuthenticationMethodOAuth2:
+    {
+        OnlineAccounts::OAuth2Reply reply(*auth_watcher_);
+        if (reply.hasError())
+        {
+            qDebug() << "Failed to authenticate:" << reply.error().text();
+        }
+        else
+        {
+            credentials_ = OAuth2Credentials{
+                reply.accessToken().toStdString(),
+            };
+        }
+        break;
+    }
+    case OnlineAccounts::AuthenticationMethodPassword:
+    {
+        // Grab hostname from account settings if available
+        string host = account_->setting("host").toString().toStdString();
+
+        OnlineAccounts::PasswordReply reply(*auth_watcher_);
+        if (reply.hasError())
+        {
+            qDebug() << "Failed to authenticate:" << reply.error().text();
+        }
+        else
+        {
+            QString username = reply.username();
+            QString password = reply.password();
+
+            // Work around password credentials bug in online-accounts-service
+            //   https://bugs.launchpad.net/bugs/1628473
+            if (username.isEmpty() && password.isEmpty())
+            {
+                username = reply.data()["UserName"].toString();
+                password = reply.data()["Secret"].toString();
+            }
+            credentials_ = PasswordCredentials{
+                username.toStdString(),
+                password.toStdString(),
+                move(host),
+            };
+        }
+        break;
+    }
+    default:
+        qDebug() << "Unhandled authentication method:"
+                 << account_->authenticationMethod();
+    }
+    auth_watcher_.reset();
+
+    Q_EMIT authenticated();
+}
+
+void OnlineAccountData::on_changed()
+{
+    // Assume that if we're in the middle of authenticating that we'll
+    // receive valid credentials for the changed account.
+    if (auth_watcher_)
+    {
+        return;
+    }
+    // Otherwise, invalidate the credentials
+    credentials_ = boost::blank();
+}
+
+}
+}
+}
+}

=== modified file 'src/provider/internal/ProviderInterface.cpp'
--- src/provider/internal/ProviderInterface.cpp	2016-11-03 02:43:43 +0000
+++ src/provider/internal/ProviderInterface.cpp	2017-03-20 04:58:30 +0000
@@ -66,18 +66,7 @@
         new Handler(account_, callback, connection(), message()));
     connect(handler.get(), &Handler::finished, this, &ProviderInterface::request_finished);
     setDelayedReply(true);
-    // If we haven't retrieved the authentication details from
-    // OnlineAccounts, delay processing the handler until then.
-    if (account_->has_credentials())
-    {
-        handler->begin();
-    }
-    else
-    {
-        account_->authenticate(true);
-        connect(account_.get(), &AccountData::authenticated,
-                handler.get(), &Handler::begin);
-    }
+    handler->begin();
     requests_.emplace(handler.get(), std::move(handler));
 }
 
@@ -210,6 +199,7 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
+                    job->p_->set_activity(account->inactivity_timer());
                     auto upload_id = QString::fromStdString(job->upload_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_write_socket();
@@ -241,6 +231,7 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
+                    job->p_->set_activity(account->inactivity_timer());
                     auto upload_id = QString::fromStdString(job->upload_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_write_socket();
@@ -303,6 +294,7 @@
                 EXEC_IN_MAIN
                 [account, message](decltype(f) f) -> QDBusMessage {
                     auto job = f.get();
+                    job->p_->set_activity(account->inactivity_timer());
                     auto download_id = QString::fromStdString(job->download_id());
                     QDBusUnixFileDescriptor file_desc;
                     int fd = job->p_->take_read_socket();

=== modified file 'src/provider/internal/ServerImpl.cpp'
--- src/provider/internal/ServerImpl.cpp	2016-08-12 06:19:56 +0000
+++ src/provider/internal/ServerImpl.cpp	2017-03-20 04:58:30 +0000
@@ -17,16 +17,19 @@
  */
 
 #include <unity/storage/provider/internal/ServerImpl.h>
-#include <unity/storage/provider/Exceptions.h>
+#include <unity/storage/internal/EnvVars.h>
 #include <unity/storage/provider/ProviderBase.h>
-#include <unity/storage/provider/internal/AccountData.h>
+#include <unity/storage/provider/internal/FixedAccountData.h>
 #include <unity/storage/provider/internal/MainLoopExecutor.h>
+#include <unity/storage/provider/internal/OnlineAccountData.h>
 #include <unity/storage/provider/internal/dbusmarshal.h>
 #include "provideradaptor.h"
 
-#include <stdexcept>
+#include <QDebug>
 
 using namespace std;
+using unity::storage::internal::EnvVars;
+using unity::storage::internal::InactivityTimer;
 
 namespace unity
 {
@@ -43,57 +46,168 @@
     , service_id_(account_service_id)
     , trace_message_handler_("storage_provider")
 {
+    qRegisterMetaType<std::exception_ptr>();
     qDBusRegisterMetaType<Item>();
     qDBusRegisterMetaType<std::vector<Item>>();
 }
 
 ServerImpl::~ServerImpl() = default;
 
-void ServerImpl::init(int& argc, char **argv)
+void ServerImpl::init(int& argc, char **argv, QDBusConnection *bus)
 {
-    app_.reset(new QCoreApplication(argc, argv));
-    auto bus = QDBusConnection::sessionBus();
-    dbus_peer_ = make_shared<DBusPeerCache>(bus);
+    if (bus)
+    {
+        bus_.reset(new QDBusConnection(*bus));
+    }
+    else
+    {
+        // Only initialise QCoreApplication if we haven't been passed
+        // in an existing bus connection.
+        app_.reset(new QCoreApplication(argc, argv));
+        bus_.reset(new QDBusConnection(QDBusConnection::sessionBus()));
+    }
+    int const timeout = EnvVars::provider_timeout_ms();
+    inactivity_timer_ = make_shared<InactivityTimer>(timeout);
+    connect(inactivity_timer_.get(), &InactivityTimer::timeout,
+            this, &ServerImpl::on_timeout);
+
+    dbus_peer_ = make_shared<DBusPeerCache>(*bus_);
 
 #ifdef SF_SUPPORTS_EXECUTORS
     // Ensure the executor is instantiated in the main thread.
     MainLoopExecutor::instance();
 #endif
 
-    manager_.reset(new OnlineAccounts::Manager("", bus));
-    connect(manager_.get(), &OnlineAccounts::Manager::ready,
-                     this, &ServerImpl::account_manager_ready);
-}
-
-void ServerImpl::run()
-{
-    app_->exec();
-}
-
-void ServerImpl::account_manager_ready()
-{
-    auto bus = QDBusConnection::sessionBus();
+    if (service_id_.empty())
+    {
+        // If we have an empty service ID, create a single instance of
+        // the provider which doesn't interact with online-accounts.
+        add_account(nullptr);
+        register_bus_name();
+    }
+    else
+    {
+        // Otherwise use online-accounts to discover all accounts
+        // providing the service ID.
+        manager_.reset(new OnlineAccounts::Manager("", *bus_));
+        connect(manager_.get(), &OnlineAccounts::Manager::ready,
+                this, &ServerImpl::on_account_manager_ready);
+        connect(manager_.get(), &OnlineAccounts::Manager::accountAvailable,
+                this, &ServerImpl::on_account_available);
+    }
+}
+
+int ServerImpl::run()
+{
+    return app_->exec();
+}
+
+void ServerImpl::register_bus_name()
+{
+    if (!bus_->registerService(QString::fromStdString(bus_name_)))
+    {
+        QString msg = "Could not acquire bus name: " + QString::fromStdString(bus_name_);
+        QString last_error = bus_->lastError().message();
+        if (!last_error.isEmpty())
+        {
+            msg += ": " + last_error;
+        }
+        qCritical().noquote() << msg;
+        app_->exit(1);
+        return;
+    }
+    // TODO: claim bus name
+    qDebug() << "Bus unique name:" << bus_->baseService();
+}
+
+void ServerImpl::add_account(OnlineAccounts::Account* account)
+{
+    OnlineAccounts::AccountId account_id = 0;
+    shared_ptr<AccountData> account_data;
+
+    if (account)
+    {
+        account_id = account->id();
+        // Ignore if we already have access to the account
+        if (interfaces_.find(account_id) != interfaces_.end())
+        {
+            return;
+        }
+
+        qDebug() << "Found account" << account->id() << "for service" << account->serviceId();
+        account_data = make_shared<OnlineAccountData>(
+            server_->make_provider(), dbus_peer_, inactivity_timer_,
+            *bus_, account);
+    }
+    else
+    {
+        account_data = make_shared<FixedAccountData>(
+            server_->make_provider(), dbus_peer_, inactivity_timer_, *bus_);
+    }
+    unique_ptr<ProviderInterface> iface(
+        new ProviderInterface(account_data));
+    // this instance is managed by Qt's parent/child memory management
+    new ProviderAdaptor(iface.get());
+
+    bus_->registerObject(QStringLiteral("/provider/%1").arg(account_id), iface.get());
+    interfaces_.emplace(account_id, std::move(iface));
+
+    // watch for account disable signals.
+    if (account)
+    {
+        connect(account, &OnlineAccounts::Account::disabled,
+                this, &ServerImpl::on_account_disabled);
+    }
+
+    Q_EMIT accountAdded();
+}
+
+void ServerImpl::remove_account(OnlineAccounts::Account* account)
+{
+    // Ignore if we don't know about this account
+    if (interfaces_.find(account->id()) == interfaces_.end())
+    {
+        return;
+    }
+
+    qDebug() << "Disabled account" << account->id() << "for service" << account->serviceId();
+    bus_->unregisterObject(QStringLiteral("/provider/%1").arg(account->id()));
+    interfaces_.erase(account->id());
+
+    Q_EMIT accountRemoved();
+}
+
+void ServerImpl::on_account_manager_ready()
+{
     for (const auto& account : manager_->availableAccounts(QString::fromStdString(service_id_)))
     {
-        qDebug() << "Found account" << account->id() << "for service" << account->serviceId();
-        auto account_data = make_shared<AccountData>(
-            server_->make_provider(), dbus_peer_, bus, account);
-        unique_ptr<ProviderInterface> iface(
-            new ProviderInterface(account_data));
-        // this instance is managed by Qt's parent/child memory management
-        new ProviderAdaptor(iface.get());
-
-        bus.registerObject(QStringLiteral("/provider/%1").arg(account->id()), iface.get());
-        interfaces_.emplace(account->id(), std::move(iface));
+        add_account(account);
     }
 
-    if (!bus.registerService(QString::fromStdString(bus_name_)))
+    register_bus_name();
+}
+
+void ServerImpl::on_account_available(OnlineAccounts::Account* account)
+{
+    // Or if the service ID doesn't match
+    if (account->serviceId() != QString::fromStdString(service_id_))
     {
-        string msg = string("Could not acquire bus name: ") + bus_name_ + ": " + bus.lastError().message().toStdString();
-        throw ResourceException(msg, int(bus.lastError().type()));
+        return;
     }
-    // TODO: claim bus name
-    qDebug() << "Bus unique name:" << bus.baseService();
+    add_account(account);
+}
+
+void ServerImpl::on_account_disabled()
+{
+    auto account = static_cast<OnlineAccounts::Account*>(sender());
+    remove_account(account);
+}
+
+void ServerImpl::on_timeout()
+{
+    int const timeout = EnvVars::provider_timeout_ms();
+    qInfo() << "Exiting after" << timeout << "ms of idle time";
+    app_->quit();
 }
 
 }

=== modified file 'src/provider/internal/TestServerImpl.cpp'
--- src/provider/internal/TestServerImpl.cpp	2016-09-28 07:04:41 +0000
+++ src/provider/internal/TestServerImpl.cpp	2017-03-20 04:58:30 +0000
@@ -17,10 +17,12 @@
  */
 
 #include <unity/storage/provider/internal/TestServerImpl.h>
+#include <unity/storage/internal/InactivityTimer.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/FixedAccountData.h>
+#include <unity/storage/provider/internal/OnlineAccountData.h>
 #include <unity/storage/provider/internal/ProviderInterface.h>
 #include <unity/storage/provider/internal/dbusmarshal.h>
 #include "provideradaptor.h"
@@ -30,6 +32,12 @@
 #include <stdexcept>
 
 using namespace std;
+using unity::storage::internal::InactivityTimer;
+
+namespace
+{
+constexpr int TIMEOUT = 30000;
+}
 
 namespace unity
 {
@@ -44,14 +52,25 @@
                                OnlineAccounts::Account* account,
                                QDBusConnection const& connection,
                                string const& object_path)
-    : connection_(connection), object_path_(object_path)
+    : connection_(connection), object_path_(object_path),
+      inactivity_timer_(make_shared<InactivityTimer>(TIMEOUT))
 {
+    qRegisterMetaType<std::exception_ptr>();
     qDBusRegisterMetaType<Item>();
     qDBusRegisterMetaType<std::vector<Item>>();
 
     auto peer_cache = make_shared<DBusPeerCache>(connection_);
-    auto account_data = make_shared<AccountData>(
-        provider, peer_cache, connection_, account);
+    shared_ptr<AccountData> account_data;
+    if (account)
+    {
+        account_data = make_shared<OnlineAccountData>(
+            provider, peer_cache, inactivity_timer_, connection_, account);
+    }
+    else
+    {
+        account_data = make_shared<FixedAccountData>(
+            provider, peer_cache, inactivity_timer_, connection_);
+    }
     interface_.reset(new ProviderInterface(account_data));
     new ProviderAdaptor(interface_.get());
 

=== modified file 'src/provider/internal/UploadJobImpl.cpp'
--- src/provider/internal/UploadJobImpl.cpp	2016-09-02 13:51:37 +0000
+++ src/provider/internal/UploadJobImpl.cpp	2017-03-20 04:58:30 +0000
@@ -30,6 +30,8 @@
 
 using namespace std;
 using namespace unity::storage::internal;
+using unity::storage::internal::ActivityNotifier;
+using unity::storage::internal::InactivityTimer;
 
 namespace unity
 {
@@ -106,6 +108,11 @@
     return sock;
 }
 
+void UploadJobImpl::set_activity(std::shared_ptr<InactivityTimer> const& inactivity_timer)
+{
+    activity_ = ActivityNotifier(inactivity_timer);
+}
+
 void UploadJobImpl::report_error(exception_ptr p)
 {
     if (read_socket_ >= 0)

=== modified file 'src/qt/client/internal/remote_client/RuntimeImpl.cpp'
--- src/qt/client/internal/remote_client/RuntimeImpl.cpp	2016-11-15 05:48:12 +0000
+++ src/qt/client/internal/remote_client/RuntimeImpl.cpp	2017-03-20 04:58:30 +0000
@@ -48,9 +48,10 @@
 static const map<QString, QString> BUS_NAMES =
 {
     { "storage-provider-test", "com.canonical.StorageFramework.Provider.ProviderTest" },
-    { "com.canonical.scopes.mcloud_mcloud_mcloud", "com.canonical.StorageFramework.Provider.McloudProvider" },
+    { "storage-provider-mcloud", "com.canonical.StorageFramework.Provider.McloudProvider" },
     { "storage-provider-owncloud", "com.canonical.StorageFramework.Provider.OwnCloud" },
     { "storage-provider-onedrive", "com.canonical.StorageFramework.Provider.OnedriveProvider" },
+    { "storage-provider-gdrive", "com.canonical.StorageFramework.Provider.GdriveProvider" },
 };
 
 }  // namespace

=== modified file 'src/qt/internal/RuntimeImpl.cpp'
--- src/qt/internal/RuntimeImpl.cpp	2016-11-21 13:29:39 +0000
+++ src/qt/internal/RuntimeImpl.cpp	2017-03-20 04:58:30 +0000
@@ -24,9 +24,11 @@
 #include <unity/storage/qt/internal/AccountImpl.h>
 #include <unity/storage/qt/internal/AccountsJobImpl.h>
 #include <unity/storage/qt/internal/StorageErrorImpl.h>
+#include <unity/storage/qt/Downloader.h>
 #include <unity/storage/qt/ItemJob.h>
 #include <unity/storage/qt/ItemListJob.h>
 #include <unity/storage/qt/Runtime.h>
+#include <unity/storage/qt/Uploader.h>
 #include <unity/storage/qt/VoidJob.h>
 #include <unity/storage/registry/Registry.h>
 
@@ -51,10 +53,12 @@
     qRegisterMetaType<unity::storage::qt::AccountsJob::Status>();
     qRegisterMetaType<unity::storage::qt::Account>();
     qRegisterMetaType<QList<unity::storage::qt::Account>>();
+    qRegisterMetaType<unity::storage::qt::Downloader::Status>();
     qRegisterMetaType<unity::storage::qt::Item>();
     qRegisterMetaType<QList<unity::storage::qt::Item>>();
     qRegisterMetaType<unity::storage::qt::ItemJob::Status>();
     qRegisterMetaType<unity::storage::qt::ItemListJob::Status>();
+    qRegisterMetaType<unity::storage::qt::Uploader::Status>();
     qRegisterMetaType<unity::storage::qt::VoidJob::Status>();
 
     qDBusRegisterMetaType<unity::storage::internal::ItemMetadata>();

=== modified file 'src/qt/internal/StorageErrorImpl.cpp'
--- src/qt/internal/StorageErrorImpl.cpp	2016-10-13 06:48:11 +0000
+++ src/qt/internal/StorageErrorImpl.cpp	2017-03-20 04:58:30 +0000
@@ -48,7 +48,8 @@
     QStringLiteral("Cancelled"),
     QStringLiteral("LogicError"),
     QStringLiteral("InvalidArgument"),
-    QStringLiteral("ResourceError")
+    QStringLiteral("ResourceError"),
+    QStringLiteral("Unauthorized"),
 };
 
 }  // namespace
@@ -77,7 +78,6 @@
            || type == StorageError::Type::Cancelled
            || type == StorageError::Type::LogicError
            || type == StorageError::Type::InvalidArgument);
-    assert(!msg.isEmpty());
 
     message_ = msg;
 }
@@ -86,7 +86,6 @@
     : StorageErrorImpl(type)
 {
     assert(type == StorageError::Type::NotExists);
-    assert(!msg.isEmpty());
 
     message_ = msg;
     item_id_ = key;
@@ -103,9 +102,6 @@
     : StorageErrorImpl(type)
 {
     assert(type == StorageError::Type::Exists);
-    assert(!msg.isEmpty());
-    assert(!item_id.isEmpty());
-    assert(!item_name.isEmpty());
 
     message_ = msg;
     item_id_ = item_id;
@@ -116,7 +112,6 @@
     : StorageErrorImpl(type)
 {
     assert(type == StorageError::Type::ResourceError);
-    assert(!msg.isEmpty());
 
     message_ = msg;
     error_code_ = error_code;

=== modified file 'src/qt/internal/unmarshal_error.cpp'
--- src/qt/internal/unmarshal_error.cpp	2016-09-29 03:17:56 +0000
+++ src/qt/internal/unmarshal_error.cpp	2017-03-20 04:58:30 +0000
@@ -82,6 +82,7 @@
     { "NotExistsException",       make_error<StorageError::Type::NotExists> },
     { "ExistsException",          make_error<StorageError::Type::Exists> },
     { "ConflictException",        make_error<StorageError::Type::Conflict> },
+    { "UnauthorizedException",    make_error<StorageError::Type::Unauthorized> },
     { "PermissionException",      make_error<StorageError::Type::PermissionDenied> },
     { "CancelledException",       make_error<StorageError::Type::Cancelled> },
     { "LogicException",           make_error<StorageError::Type::LogicError> },

=== modified file 'src/registry/CMakeLists.txt'
--- src/registry/CMakeLists.txt	2016-11-21 04:24:13 +0000
+++ src/registry/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -1,8 +1,3 @@
-include_directories(
-    ${CMAKE_CURRENT_BINARY_DIR}
-    ${ONLINEACCOUNTS_DEPS_INCLUDE_DIRS}
-)
-
 set(TARGET "storage-framework-registry")
 
 qt5_add_dbus_adaptor(adaptor_files
@@ -16,24 +11,36 @@
     GENERATED TRUE
 )
 
-add_executable(${TARGET}
+add_library(registry-static STATIC
     internal/ListAccountsHandler.cpp
     internal/qdbus-last-error-msg.cpp
     internal/RegistryAdaptor.cpp
-    main.cpp
     ${CMAKE_SOURCE_DIR}/include/unity/storage/registry/internal/ListAccountsHandler.h
     ${CMAKE_SOURCE_DIR}/include/unity/storage/registry/internal/RegistryAdaptor.h
     ${adaptor_files})
 
-set_target_properties(${TARGET} PROPERTIES AUTOMOC TRUE)
-
-target_link_libraries(${TARGET}
+set_target_properties(registry-static PROPERTIES AUTOMOC TRUE)
+
+target_include_directories(registry-static PUBLIC
+    ${GLIB_DEPS_INCLUDE_DIRS}
+    ${ONLINEACCOUNTS_DEPS_INCLUDE_DIRS}
+)
+
+target_link_libraries(registry-static PUBLIC
     storage-framework-common-internal
     Qt5::Core
     Qt5::DBus
+    ${GLIB_DEPS_LDFLAGS}
     ${ONLINEACCOUNTS_DEPS_LDFLAGS}
 )
 
+add_executable(${TARGET}
+    main.cpp
+)
+target_link_libraries(${TARGET}
+    registry-static
+)
+
 install(
     TARGETS ${TARGET}
     RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}

=== modified file 'src/registry/internal/ListAccountsHandler.cpp'
--- src/registry/internal/ListAccountsHandler.cpp	2016-11-28 11:04:17 +0000
+++ src/registry/internal/ListAccountsHandler.cpp	2017-03-20 04:58:30 +0000
@@ -21,6 +21,11 @@
 #include <unity/storage/internal/AccountDetails.h>
 #include <unity/storage/registry/internal/qdbus-last-error-msg.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#include <glib.h>
+#pragma GCC diagnostic pop
+
 #include <OnlineAccounts/Account>
 #include <QDebug>
 
@@ -65,9 +70,10 @@
 static map<QString, ProviderDetails> const BUS_NAMES =
 {
     { "storage-provider-test", { "com.canonical.StorageFramework.Provider.ProviderTest", "Test Provider" } },
-    { "com.canonical.scopes.mcloud_mcloud_mcloud", { "com.canonical.StorageFramework.Provider.McloudProvider", "mcloud" } },
+    { "storage-provider-mcloud", { "com.canonical.StorageFramework.Provider.McloudProvider", "mcloud" } },
     { "storage-provider-owncloud", { "com.canonical.StorageFramework.Provider.OwnCloud", "ownCloud" } },
     { "storage-provider-onedrive", { "com.canonical.StorageFramework.Provider.OnedriveProvider", "OneDrive" } },
+    { "storage-provider-gdrive", { "com.canonical.StorageFramework.Provider.GdriveProvider", "GDrive" } },
 };
 
 }  // namespace
@@ -99,6 +105,17 @@
         accounts.append(ad);
     }
 
+    // Add an entry for the local provider, which Online Accounts doesn't know about.
+    storage::internal::AccountDetails ad;
+    ad.busName = "com.canonical.StorageFramework.Provider.Local";
+    ad.objectPath = QDBusObjectPath(QStringLiteral("/provider/0"));
+    ad.id = 0;
+    ad.serviceId = "";
+    ad.displayName = g_get_user_name();
+    ad.providerName = "Local Provider";
+    ad.iconName = "";
+    accounts.append(ad);
+
     if (!conn_.send(msg_.createReply(QVariant::fromValue(accounts))))
     {
         auto msg = last_error_msg(conn_);

=== modified file 'src/registry/main.cpp'
--- src/registry/main.cpp	2016-11-22 07:23:48 +0000
+++ src/registry/main.cpp	2017-03-20 04:58:30 +0000
@@ -50,12 +50,14 @@
         auto conn = QDBusConnection::sessionBus();
 
         int const timeout_ms = internal::EnvVars::registry_timeout_ms();
-        auto timeout_func = [&app, timeout_ms]
-        {
-            qInfo().noquote().nospace() << "Exiting after " << QString::number(timeout_ms) << " ms of idle time";
-            app.quit();
-        };
-        auto inactivity_timer = make_shared<unity::storage::internal::InactivityTimer>(timeout_ms, timeout_func);
+        auto inactivity_timer = make_shared<unity::storage::internal::InactivityTimer>(timeout_ms);
+        QObject::connect(
+            inactivity_timer.get(), &unity::storage::internal::InactivityTimer::timeout,
+            [&app, timeout_ms]
+            {
+                qInfo().noquote().nospace() << "Exiting after " << QString::number(timeout_ms) << " ms of idle time";
+                app.quit();
+            });
 
         registry::internal::RegistryAdaptor registry_adaptor(conn, inactivity_timer);
         new ::RegistryAdaptor(&registry_adaptor);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-11-28 10:54:49 +0000
+++ tests/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -8,11 +8,13 @@
 set(unit_test_dirs
     registry
     local-client
+    local-provider
     remote-client
     remote-client-v1
     provider-AccountData
     provider-DBusPeerCache
     provider-ProviderInterface
+    provider-Server
 )
 
 set(slow_test_dirs

=== modified file 'tests/copyright/check_copyright.sh'
--- tests/copyright/check_copyright.sh	2016-11-29 06:39:29 +0000
+++ tests/copyright/check_copyright.sh	2017-03-20 04:58:30 +0000
@@ -36,7 +36,7 @@
 source_dir="$1"
 ignore_dir="${2:-}"
 
-ignore_pat="\\.sci$|\\.swp$|\\.bzr|debian|qmldir|HACKING|ubsan-suppress|valgrind-suppress|\\.txt$|\\.xml$|\\.in$|\\.dox$|\\.yaml$"
+ignore_pat="/parts/|/stage/|/prime/|~$|\\.sci$|\\.swp$|\\.bzr|debian|qmldir|HACKING|ubsan-suppress|valgrind-suppress|\\.txt$|\\.xml$|\\.in$|\\.dox$|\\.yaml$"
 
 #
 # We don't use the -i option of licensecheck to add ignore_dir to the pattern because Jenkins creates directories

=== added directory 'tests/local-provider'
=== added file 'tests/local-provider/CMakeLists.txt'
--- tests/local-provider/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/local-provider/CMakeLists.txt	2017-03-20 04:58:30 +0000
@@ -0,0 +1,18 @@
+add_executable(local-provider_test local-provider_test.cpp)
+
+add_definitions(-DTEST_DIR="${CMAKE_CURRENT_BINARY_DIR}" -DBOOST_THREAD_VERSION=4)
+
+target_link_libraries(local-provider_test
+    local-provider-lib
+    storage-framework-provider
+    storage-framework-qt-client-v2
+    Qt5::Test
+    ${Boost_LIBRARIES}
+    ${GLIB_DEPS_LIBRARIES}
+    ${GIO_DEPS_LIBRARIES}
+    testutils
+    gtest
+)
+add_test(local-provider local-provider_test)
+
+set(UNIT_TEST_TARGETS ${UNIT_TEST_TARGETS} PARENT_SCOPE)

=== added file 'tests/local-provider/local-provider_test.cpp'
--- tests/local-provider/local-provider_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/local-provider/local-provider_test.cpp	2017-03-20 04:58:30 +0000
@@ -0,0 +1,1476 @@
+/*
+ * Copyright (C) 2017 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 "../../src/local-provider/LocalDownloadJob.h"
+#include "../../src/local-provider/LocalProvider.h"
+#include "../../src/local-provider/LocalUploadJob.h"
+
+#include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/Exceptions.h>
+#include <unity/storage/provider/Server.h>
+#include <unity/storage/qt/client-api.h>
+#include <utils/env_var_guard.h>
+#include <utils/ProviderFixture.h>
+
+#include <boost/algorithm/string.hpp>
+#include <gtest/gtest.h>
+#include <QCoreApplication>
+#include <QSignalSpy>
+
+#include <chrono>
+#include <regex>
+
+#include <fcntl.h>
+
+using namespace unity::storage;
+using namespace std;
+
+namespace
+{
+
+int64_t nanosecs_now()
+{
+    return chrono::system_clock::now().time_since_epoch() / chrono::nanoseconds(1);
+}
+
+class LocalProviderTest : public ProviderFixture
+{
+protected:
+    void SetUp() override
+    {
+        tmp_dir_.reset(new QTemporaryDir(TEST_DIR "/data.XXXXXX"));
+        ASSERT_TRUE(tmp_dir_->isValid());
+        setenv("SF_LOCAL_PROVIDER_ROOT", ROOT_DIR().c_str(), true);
+
+        ProviderFixture::SetUp();
+        runtime_.reset(new qt::Runtime(connection()));
+        acc_ = runtime_->make_test_account(service_connection_->baseService(), object_path());
+    }
+
+    void TearDown() override
+    {
+        runtime_.reset();
+        ProviderFixture::TearDown();
+        if (HasFailure())
+        {
+            tmp_dir_->setAutoRemove(false);
+        }
+        tmp_dir_.reset();
+    }
+
+    std::string ROOT_DIR() const
+    {
+        return tmp_dir_->path().toStdString();
+    }
+
+    std::unique_ptr<QTemporaryDir> tmp_dir_;
+    unique_ptr<qt::Runtime> runtime_;
+    qt::Account acc_;
+};
+
+constexpr int SIGNAL_WAIT_TIME = 30000;
+
+template <typename Job>
+void wait(Job* job)
+{
+    QSignalSpy spy(job, &Job::statusChanged);
+    while (job->status() == Job::Loading)
+    {
+        if (!spy.wait(SIGNAL_WAIT_TIME))
+        {
+            throw runtime_error("Wait for statusChanged signal timed out");
+        }
+    }
+}
+
+qt::Item get_root(qt::Account const& account)
+{
+    unique_ptr<qt::ItemListJob> j(account.roots());
+    assert(j->isValid());
+    QSignalSpy ready_spy(j.get(), &qt::ItemListJob::itemsReady);
+    assert(ready_spy.wait(SIGNAL_WAIT_TIME));
+    auto arg = ready_spy.takeFirst();
+    auto items = qvariant_cast<QList<qt::Item>>(arg.at(0));
+    assert(items.size() == 1);
+    return items[0];
+}
+
+QList<qt::Item> get_items(qt::ItemListJob *job)
+{
+    QList<qt::Item> items;
+    auto connection = QObject::connect(
+        job, &qt::ItemListJob::itemsReady,
+        [&](QList<qt::Item> const& new_items)
+        {
+            items.append(new_items);
+        });
+    try
+    {
+        wait(job);
+    }
+    catch (...)
+    {
+        QObject::disconnect(connection);
+        throw;
+    }
+    QObject::disconnect(connection);
+    return items;
+}
+
+const string file_contents =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
+    "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut "
+    "enim ad minim veniam, quis nostrud exercitation ullamco laboris "
+    "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor "
+    "in reprehenderit in voluptate velit esse cillum dolore eu fugiat "
+    "nulla pariatur. Excepteur sint occaecat cupidatat non proident, "
+    "sunt in culpa qui officia deserunt mollit anim id est laborum.\n";
+
+}  // namespace
+
+TEST(Directories, env_vars)
+{
+    // These tests cause the constructor to throw, so we instantiate the provider directly.
+
+    {
+        EnvVarGuard env("SF_LOCAL_PROVIDER_ROOT", "/no_such_dir");
+
+        try
+        {
+            LocalProvider();
+            FAIL();
+        }
+        catch (provider::InvalidArgumentException const& e)
+        {
+            EXPECT_STREQ("InvalidArgumentException: LocalProvider(): Environment variable "
+                         "SF_LOCAL_PROVIDER_ROOT must denote an existing directory",
+                         e.what());
+        }
+    }
+
+    {
+        EnvVarGuard env("SF_LOCAL_PROVIDER_ROOT", TEST_DIR "/Makefile");
+
+        try
+        {
+            LocalProvider();
+            FAIL();
+        }
+        catch (provider::InvalidArgumentException const& e)
+        {
+            EXPECT_STREQ("InvalidArgumentException: LocalProvider(): Environment variable "
+                         "SF_LOCAL_PROVIDER_ROOT must denote an existing directory",
+                         e.what());
+        }
+    }
+
+    {
+        string const dir = TEST_DIR "/noperm";
+
+        mkdir(dir.c_str(), 0555);
+        ASSERT_EQ(0, chmod(dir.c_str(), 0555));  // In case dir was there already.
+
+        EnvVarGuard env1("SF_LOCAL_PROVIDER_ROOT", nullptr);
+        EnvVarGuard env2("XDG_DATA_HOME", dir.c_str());
+
+        using namespace boost::filesystem;
+
+        try
+        {
+            LocalProvider();
+            ASSERT_EQ(0, chmod(dir.c_str(), 0775));
+            remove_all(dir);
+            FAIL();
+        }
+        catch (provider::PermissionException const& e)
+        {
+            EXPECT_EQ(string("PermissionException: LocalProvider(): \"") + dir + "/storage-framework\": "
+                      "boost::filesystem::create_directories: Permission denied: \"" + dir + "/storage-framework\"",
+                      e.what());
+        }
+
+        ASSERT_EQ(0, chmod(dir.c_str(), 0775));
+        ASSERT_TRUE(remove_all(dir));
+
+        // Try again, which must succeed now (for coverage).
+        LocalProvider();
+        ASSERT_TRUE(is_directory(dir + "/storage-framework/local"));
+        ASSERT_TRUE(remove_all(dir));
+    }
+
+    {
+        string const dir = TEST_DIR "/snap_user_common";
+        mkdir(dir.c_str(), 0775);
+
+        EnvVarGuard env1("SF_LOCAL_PROVIDER_ROOT", nullptr);
+        EnvVarGuard env2("SNAP_USER_COMMON", dir.c_str());
+
+        using namespace boost::filesystem;
+
+        LocalProvider();
+        ASSERT_TRUE(exists(dir + "/storage-framework/local"));
+        ASSERT_TRUE(remove_all(dir));
+    }
+}
+
+TEST_F(LocalProviderTest, basic)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    // Basic sanity check, get the root.
+    unique_ptr<ItemListJob> j(acc_.roots());
+    EXPECT_TRUE(j->isValid());
+    QSignalSpy ready_spy(j.get(), &ItemListJob::itemsReady);
+    ASSERT_TRUE(ready_spy.wait(SIGNAL_WAIT_TIME));
+    ASSERT_EQ(1, ready_spy.count());
+    auto arg = ready_spy.takeFirst();
+    auto items = qvariant_cast<QList<Item>>(arg.at(0));
+    ASSERT_EQ(1, items.size());
+
+    // Check contents of returned item.
+    auto root = items[0];
+    EXPECT_TRUE(root.isValid());
+    EXPECT_EQ(Item::Type::Root, root.type());
+    EXPECT_EQ(ROOT_DIR(), root.itemId().toStdString());
+    EXPECT_EQ("/", root.name());
+    EXPECT_EQ("", root.etag());
+    EXPECT_EQ(QList<QString>(), root.parentIds());
+    qDebug() << root.lastModifiedTime();
+    EXPECT_TRUE(root.lastModifiedTime().isValid());
+    EXPECT_EQ(acc_, root.account());
+
+    ASSERT_EQ(5, root.metadata().size());
+    auto free_space_bytes = root.metadata().value("free_space_bytes").toULongLong();
+    cout << "free_space_bytes: " << free_space_bytes << endl;
+    EXPECT_GT(free_space_bytes, 0);
+    auto used_space_bytes = root.metadata().value("used_space_bytes").toULongLong();
+    cout << "used_space_bytes: " << used_space_bytes << endl;
+    EXPECT_GT(used_space_bytes, 0);
+    auto content_type = root.metadata().value("content_type").toString();
+    EXPECT_EQ("inode/directory", content_type);
+    auto writable = root.metadata().value("writable").toBool();
+    EXPECT_TRUE(writable);
+
+    // yyyy-mm-ddThh:mm:ssZ
+    string const date_time_fmt = "^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]Z$";
+    string mtime = root.metadata().value("last_modified_time").toString().toStdString();
+    cout << "last_modified_time: " << mtime << endl;
+    regex re(date_time_fmt);
+    EXPECT_TRUE(regex_match(mtime, re));
+}
+
+TEST_F(LocalProviderTest, create_folder)
+{
+    {
+        using namespace unity::storage::qt;
+
+        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+        auto root = get_root(acc_);
+        unique_ptr<ItemJob> job(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+
+        Item child = job->item();
+        EXPECT_EQ(ROOT_DIR() + "/child", child.itemId().toStdString());
+        EXPECT_EQ("child", child.name().toStdString());
+        ASSERT_EQ(1, child.parentIds().size());
+        EXPECT_EQ(ROOT_DIR(), child.parentIds().at(0).toStdString());
+        EXPECT_EQ("", child.etag());
+        EXPECT_EQ(Item::Type::Folder, child.type());
+        EXPECT_EQ(5, child.metadata().size());
+
+        struct stat st;
+        ASSERT_EQ(0, stat(child.itemId().toStdString().c_str(), &st));
+        EXPECT_TRUE(S_ISDIR(st.st_mode));
+
+        // Again, to get coverage for a StorageException caught in invoke_async().
+        job.reset(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
+        EXPECT_EQ(string("Exists: create_folder(): \"") + ROOT_DIR() + "/child\" exists already",
+                  job->error().errorString().toStdString());
+
+        // Again, without write permission on the root dir, to get coverage for a filesystem_error in invoke_async().
+        ASSERT_EQ(0, ::rmdir((ROOT_DIR() + "/child").c_str()));
+        ASSERT_EQ(0, ::chmod(ROOT_DIR().c_str(), 0555));
+        job.reset(root.createFolder("child"));
+        wait(job.get());
+        ::chmod(ROOT_DIR().c_str(), 0755);
+        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
+        EXPECT_EQ(string("PermissionDenied: create_folder(): \"") + ROOT_DIR()
+                  + "/child\": boost::filesystem::create_directory: Permission denied: \"" + ROOT_DIR() + "/child\"",
+                  job->error().errorString().toStdString());
+    }
+}
+
+TEST_F(LocalProviderTest, delete_item)
+{
+    {
+        using namespace unity::storage::qt;
+
+        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+        auto root = get_root(acc_);
+        unique_ptr<ItemJob> job(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+
+        Item child = job->item();
+        unique_ptr<VoidJob> delete_job(child.deleteItem());
+        wait(delete_job.get());
+        ASSERT_EQ(ItemJob::Finished, delete_job->status()) << delete_job->error().errorString().toStdString();
+
+        struct stat st;
+        ASSERT_EQ(-1, stat(child.itemId().toStdString().c_str(), &st));
+        EXPECT_EQ(ENOENT, errno);
+    }
+}
+
+TEST_F(LocalProviderTest, delete_item_noperm)
+{
+    {
+        using namespace unity::storage::qt;
+
+        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+        auto root = get_root(acc_);
+        unique_ptr<ItemJob> job(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+    }
+}
+
+TEST_F(LocalProviderTest, delete_root)
+{
+    // Client-side API does not allow us to try to delete the root, so we talk to the provider directly.
+    auto p = make_shared<LocalProvider>();
+
+    auto fut = p->delete_item(ROOT_DIR(), provider::Context());
+    try
+    {
+        fut.get();
+        FAIL();
+    }
+    catch (provider::LogicException const& e)
+    {
+        EXPECT_STREQ("LogicException: delete_item(): cannot delete root", e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, metadata)
+{
+    // Client-side API does not call the Metadata DBus method (except as part of parents()),
+    // so we talk to the provider directly.
+    auto p = make_shared<LocalProvider>();
+
+    auto fut = p->metadata(ROOT_DIR(), {}, provider::Context());
+    auto item = fut.get();
+    EXPECT_EQ(5, item.metadata.size());
+
+    // Again, to get coverage for the "not file or folder" case in make_item().
+    ASSERT_EQ(0, mknod((ROOT_DIR() + "/pipe").c_str(), S_IFIFO | 06666, 0));
+    try
+    {
+        auto fut = p->metadata(ROOT_DIR() + "/pipe", {}, provider::Context());
+        fut.get();
+        FAIL();
+    }
+    catch (provider::NotExistsException const& e)
+    {
+        EXPECT_EQ(string("NotExistsException: metadata(): \"") + ROOT_DIR() + "/pipe\" is neither a file nor a folder",
+                  e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, lookup)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto root = get_root(acc_);
+    {
+        unique_ptr<ItemJob> job(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+    }
+
+    unique_ptr<ItemListJob> job(root.lookup("child"));
+    auto items = get_items(job.get());
+    ASSERT_EQ(1, items.size());
+    auto child = items.at(0);
+
+    EXPECT_EQ(ROOT_DIR() + "/child", child.itemId().toStdString());
+    EXPECT_EQ("child", child.name().toStdString());
+    ASSERT_EQ(1, child.parentIds().size());
+    EXPECT_EQ(ROOT_DIR(), child.parentIds().at(0).toStdString());
+    EXPECT_EQ("", child.etag());
+    EXPECT_EQ(Item::Type::Folder, child.type());
+    EXPECT_EQ(5, child.metadata().size());
+
+    // Remove the child again and try the lookup once more.
+    ASSERT_EQ(0, rmdir((ROOT_DIR() + "/child").c_str()));
+
+    job.reset(root.lookup("child"));
+    wait(job.get());
+    EXPECT_EQ(ItemJob::Error, job->status());
+    EXPECT_EQ(string("NotExists: lookup(): \"") + ROOT_DIR() + "/child\": boost::filesystem::canonical: "
+              + "No such file or directory: \"" + ROOT_DIR() + "/child\"",
+              job->error().errorString().toStdString());
+}
+
+TEST_F(LocalProviderTest, list)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto root = get_root(acc_);
+    {
+        unique_ptr<ItemJob> job(root.createFolder("child"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+    }
+
+    // Make a weird item that will be ignored (for coverage).
+    ASSERT_EQ(0, mknod((ROOT_DIR() + "/pipe").c_str(), S_IFIFO | 06666, 0));
+
+    // Make a file that starts with the temp file prefix (for coverage).
+    int fd = creat((ROOT_DIR() + "/.storage-framework").c_str(), 0755);
+    ASSERT_GT(fd, 0);
+    close(fd);
+
+    unique_ptr<ItemListJob> job(root.list());
+    auto items = get_items(job.get());
+    ASSERT_EQ(1, items.size());
+    auto child = items.at(0);
+
+    EXPECT_EQ(ROOT_DIR() + "/child", child.itemId().toStdString());
+    EXPECT_EQ("child", child.name().toStdString());
+    ASSERT_EQ(1, child.parentIds().size());
+    EXPECT_EQ(ROOT_DIR(), child.parentIds().at(0).toStdString());
+    EXPECT_EQ("", child.etag());
+    EXPECT_EQ(Item::Type::Folder, child.type());
+    EXPECT_EQ(5, child.metadata().size());
+}
+
+void make_hierarchy(string const& root_dir)
+{
+    // Make a small tree so we have something to test with for move() and copy().
+    ASSERT_EQ(0, mkdir((root_dir + "/a").c_str(), 0755));
+    ASSERT_EQ(0, mkdir((root_dir + "/a/b").c_str(), 0755));
+    string cmd = string("echo hello >") + root_dir + "/hello";
+    ASSERT_EQ(0, system(cmd.c_str()));
+    cmd = string("echo text >") + root_dir + "/a/foo.txt";
+    ASSERT_EQ(0, system(cmd.c_str()));
+    ASSERT_EQ(0, mknod((root_dir + "/a/pipe").c_str(), S_IFIFO | 06666, 0));
+    ASSERT_EQ(0, mkdir((root_dir + "/a/.storage-framework-").c_str(), 0755));
+    ASSERT_EQ(0, mkdir((root_dir + "/a/b/.storage-framework-").c_str(), 0755));
+    ASSERT_EQ(0, mknod((root_dir + "/a/b/pipe").c_str(), S_IFIFO | 06666, 0));
+}
+
+TEST_F(LocalProviderTest, move)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto start_time = nanosecs_now();
+
+    make_hierarchy(ROOT_DIR());
+
+    auto root = get_root(acc_);
+
+    qt::Item hello;
+    {
+        unique_ptr<ItemListJob> job(root.lookup("hello"));
+        auto items = get_items(job.get());
+        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
+        ASSERT_EQ(1, items.size());
+        hello = items.at(0);
+    }
+
+    struct stat st;
+    ASSERT_EQ(0, stat(hello.itemId().toStdString().c_str(), &st));
+    auto old_ino = st.st_ino;
+
+    // Check metadata.
+    EXPECT_EQ("hello", hello.name());
+    ASSERT_EQ(1, hello.parentIds().size());
+    EXPECT_EQ(ROOT_DIR(), hello.parentIds().at(0).toStdString());
+    EXPECT_EQ(Item::Type::File, hello.type());
+
+    ASSERT_EQ(6, hello.metadata().size());
+    auto free_space_bytes = hello.metadata().value("free_space_bytes").toLongLong();
+    cout << "free_space_bytes: " << free_space_bytes << endl;
+    EXPECT_GT(free_space_bytes, 0);
+    auto used_space_bytes = hello.metadata().value("used_space_bytes").toLongLong();
+    cout << "used_space_bytes: " << used_space_bytes << endl;
+    EXPECT_GT(used_space_bytes, 0);
+    auto content_type = hello.metadata().value("content_type").toString();
+    EXPECT_EQ("application/octet-stream", content_type);
+    auto writable = hello.metadata().value("writable").toBool();
+    EXPECT_TRUE(writable);
+    auto size = hello.metadata().value("size_in_bytes").toLongLong();
+    EXPECT_EQ(6, size);
+
+    // yyyy-mm-ddThh:mm:ssZ
+    string const date_time_fmt = "^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]Z$";
+    string date_time = hello.metadata().value("last_modified_time").toString().toStdString();
+    cout << "last_modified_time: " << date_time << endl;
+    regex re(date_time_fmt);
+    EXPECT_TRUE(regex_match(date_time, re));
+
+    // Check that the file was modified in the last two seconds.
+    // Because the system clock can tick a lot more frequently than the file system time stamp,
+    // we allow the mtime to be up to one second *earlier* than the time we started the operation.
+    string mtime_str = hello.etag().toStdString();
+    char* end;
+    int64_t mtime = strtoll(mtime_str.c_str(), &end, 10);
+    EXPECT_LE(start_time - 1000000000, mtime);
+    EXPECT_LT(mtime, start_time + 2000000000);
+
+    // Move hello -> world
+    qt::Item world;
+    {
+        unique_ptr<ItemJob> job(hello.move(root, "world"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+        world = job->item();
+    }
+    EXPECT_FALSE(boost::filesystem::exists(hello.itemId().toStdString()));
+    EXPECT_EQ(ROOT_DIR() + "/world", world.itemId().toStdString());
+
+    ASSERT_EQ(0, stat(world.itemId().toStdString().c_str(), &st));
+    auto new_ino = st.st_ino;
+    EXPECT_EQ(old_ino, new_ino);
+
+    // For coverage: try moving world -> a (which must fail)
+    unique_ptr<ItemJob> job(world.move(root, "a"));
+    wait(job.get());
+    ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
+    EXPECT_EQ(string("Exists: move(): \"") + ROOT_DIR() + "/a\" exists already",
+              job->error().errorString().toStdString());
+}
+
+TEST_F(LocalProviderTest, copy_file)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    make_hierarchy(ROOT_DIR());
+
+    auto root = get_root(acc_);
+
+    // Copy hello -> world
+    qt::Item hello;
+    {
+        unique_ptr<ItemListJob> job(root.lookup("hello"));
+        auto items = get_items(job.get());
+        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
+        ASSERT_EQ(1, items.size());
+        hello = items.at(0);
+    }
+
+    struct stat st;
+    ASSERT_EQ(0, stat(hello.itemId().toStdString().c_str(), &st));
+    auto old_ino = st.st_ino;
+
+    qt::Item world;
+    {
+        unique_ptr<ItemJob> job(hello.copy(root, "world"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+        world = job->item();
+    }
+    EXPECT_TRUE(boost::filesystem::exists(hello.itemId().toStdString()));
+    EXPECT_EQ(ROOT_DIR() + "/world", world.itemId().toStdString());
+
+    ASSERT_EQ(0, stat(world.itemId().toStdString().c_str(), &st));
+    auto new_ino = st.st_ino;
+    EXPECT_NE(old_ino, new_ino);
+}
+
+TEST_F(LocalProviderTest, copy_tree)
+{
+    using namespace unity::storage::qt;
+    using namespace boost::filesystem;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    make_hierarchy(ROOT_DIR());
+
+    auto root = get_root(acc_);
+
+    // Copy a -> c
+    qt::Item a;
+    {
+        unique_ptr<ItemListJob> job(root.lookup("a"));
+        auto items = get_items(job.get());
+        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
+        ASSERT_EQ(1, items.size());
+        a = items.at(0);
+    }
+
+    qt::Item c;
+    {
+        unique_ptr<ItemJob> job(a.copy(root, "c"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+        c = job->item();
+    }
+    EXPECT_TRUE(exists(c.itemId().toStdString()));
+
+    // Check that we only copied regular files and directories, but not a pipe or anything starting with
+    // the temp file prefix.
+    EXPECT_TRUE(exists(ROOT_DIR() + "/c/b"));
+    EXPECT_TRUE(exists(ROOT_DIR() + "/c/foo.txt"));
+    EXPECT_FALSE(exists(ROOT_DIR() + "/c/pipe"));
+    EXPECT_FALSE(exists(ROOT_DIR() + "/c/storage-framework-"));
+    EXPECT_FALSE(exists(ROOT_DIR() + "/c/b/pipe"));
+    EXPECT_FALSE(exists(ROOT_DIR() + "/c/b/storage-framework-"));
+
+    // Copy c -> a. This must fail because a exists.
+    {
+        unique_ptr<ItemJob> job(c.copy(root, "a"));
+        wait(job.get());
+        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
+        EXPECT_EQ(string("Exists: copy(): \"") + ROOT_DIR() + "/a\" exists already",
+                  job->error().errorString().toStdString());
+    }
+}
+
+TEST_F(LocalProviderTest, download)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    int const segments = 10000;
+    string large_contents;
+    large_contents.reserve(file_contents.size() * segments);
+    for (int i = 0; i < segments; i++)
+    {
+        large_contents += file_contents;
+    }
+    string const full_path = ROOT_DIR() + "/foo.txt";
+    {
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(ssize_t(large_contents.size()), write(fd, &large_contents[0], large_contents.size())) << strerror(errno);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
+
+    int64_t n_read = 0;
+    QObject::connect(downloader.get(), &QIODevice::readyRead,
+                     [&]() {
+                         auto bytes = downloader->readAll();
+                         string const expected = large_contents.substr(n_read, bytes.size());
+                         EXPECT_EQ(expected, bytes.toStdString());
+                         n_read += bytes.size();
+                     });
+    QSignalSpy read_finished_spy(downloader.get(), &QIODevice::readChannelFinished);
+    ASSERT_TRUE(read_finished_spy.wait(SIGNAL_WAIT_TIME));
+
+    QSignalSpy status_spy(downloader.get(), &Downloader::statusChanged);
+    downloader->close();
+    while (downloader->status() == Downloader::Ready)
+    {
+        ASSERT_TRUE(status_spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Downloader::Finished, downloader->status()) << downloader->error().errorString().toStdString();
+
+    EXPECT_EQ(int64_t(large_contents.size()), n_read);
+}
+
+TEST_F(LocalProviderTest, download_short_read)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    int const segments = 10000;
+    string const full_path = ROOT_DIR() + "/foo.txt";
+    {
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        for (int i = 0; i < segments; i++)
+        {
+            ASSERT_EQ(ssize_t(file_contents.size()), write(fd, &file_contents[0], file_contents.size())) << strerror(errno);
+        }
+        ASSERT_EQ(0, close(fd));
+    }