Merge lp:~michihenning/storage-framework/local-provider into lp:storage-framework/devel

[Michi Henning]

Added proper local provider.

Added proper local provider. Still need to update the registry to return an account for the provider, but will do that in a separate MR.

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

FAILED: Continuous integration, rev:108
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/251/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1777/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1784
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1560/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1560/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1560/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1560/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1560/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1560/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:110
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/252/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1778/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1785
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1561/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1561/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1561/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1561/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1561/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1561/console

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

review: Needs Fixing (continuous-integration)

[James Henstridge (jamesh)]

Attached is a partial review covering just the provider code. I haven't looked at any of the test changes yet.

review: Needs Fixing

[lp:~michihenning/storage-framework/local-provider]

111. By Michi Henning on 2017-03-15

Review comments from James.

112. By Michi Henning on 2017-03-15

Fix debian install file.

[Michi Henning (michihenning)]

Thanks for the review! I've responded inline.

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

PASSED: Continuous integration, rev:112
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/253/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1781
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1788
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1564/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1564/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1564/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1564/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1564/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1564
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1564/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~michihenning/storage-framework/local-provider]

113. By Michi Henning on 2017-03-15

Using gobj_ptr now.

114. By Michi Henning on 2017-03-16

Pay attention to SNAP_USER_DATA, plus other minor changes discussed with James.

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

PASSED: Continuous integration, rev:114
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/254/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1785
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1792
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1568/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1568/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1568/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1568/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1568/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1568
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1568/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[James Henstridge (jamesh)]

Can't easily leave inline comments for a diff this big, so I'll just note them here:

[1]
storage-provider-local should not be in the libstorage-framework-provider-1 binary package: that package is "Multi-Arch: same" (meaning one copy of the package for each architecture on multi-arch) systems), when we want it in a "Multi-Arch: foreign" (meaning only one copy is needed, and it can be used to satisfy deps of other packages. Also, the local provider is not strictly needed by other providers using this library.

Perhaps the storage-framework-registry binary package would be a better home?

[2]
I don't see a D-Bus service activation file for the local provider. It should be included in the same binary package as the local provider.

[3]
This is a bit of an annoying one since it will be a lot of search and replace, but is STORAGE_FRAMEWORK_ROOT a good name for the environment variable? It is controlling one particular provider rather than the entire framework.

Looking at some of the other environment variables we've got, perhaps SF_LOCAL_PROVIDER_ROOT would fit the pattern better?

[4]
This can probably be put off post-merge: we should probably have the local-provider tests use a unique temporary directory for each run to ensure that it can't interfere with other tests.

This can wait though, since what you've got is fine for a single serial run of the tests.

[5]
I don't see anything in the storage-framework-registry to let clients discover the local provider. Should that be covered in this branch, or should it be handled in a follow up?

review: Needs Fixing

[lp:~michihenning/storage-framework/local-provider]

115. By Michi Henning on 2017-03-17

Renamed STORAGE_FRAMEWORK_ROOT to SF_LOCAL_PROVIDER_ROOT.
Added .service file and fixed debian packaging.

116. By Michi Henning on 2017-03-17

Updated debian Standards-Version.

[Michi Henning (michihenning)]

1: Fixed, thanks!
2: Blush... I plain forgot :-(
3: Done, wasn't a big deal, and I agree that this is a better name.
4: The test fixture removes the tree at the start of each test run.
5: I was going to do that in a separate MR.

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

PASSED: Continuous integration, rev:116
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/263/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1808
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1815
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1591/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1591/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1591/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1591/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1591/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1591
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1591/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[James Henstridge (jamesh)]

Looks good.

My point about the temporary directory is that it adds a dependency on a scarce resource when we don't need to. If I ran this test suite twice in parallel, it would fail because one instance would be deleting files the other was expecting to find. The same would happen if we had a test runner that could invoke tests in parallel.

It doesn't have much practical effect right now because we are running tests serially, but I like to avoid these kinds of dependencies when possible.

review: Approve

[Michi Henning (michihenning)]

Fair enough. I'll push a separate MR for it.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-02-24 03:01:57 +0000
+++ CMakeLists.txt	2017-03-17 05:04:57 +0000
@@ -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")
@@ -123,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)
 
@@ -137,6 +138,7 @@
 
 enable_coverage_report(
     TARGETS
+        local-provider-lib
         qt-client-lib-common
         storage-framework-common-internal
         storage-framework-qt-client
@@ -145,6 +147,7 @@
         sf-provider-objects
         storage-framework-provider
         storage-framework-registry
+        storage-provider-local
     FILTER
         ${CMAKE_SOURCE_DIR}/tests/*
         ${CMAKE_BINARY_DIR}/*

=== modified file 'debian/control.in'
--- debian/control.in	2016-12-12 02:18:21 +0000
+++ debian/control.in	2017-03-17 05:04:57 +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-17 05:04:57 +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

=== 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-17 05:04:57 +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	2017-01-27 09:28:03 +0000
+++ include/unity/storage/provider/Exceptions.h	2017-03-17 05:04:57 +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
 {

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

=== 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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +0000
@@ -0,0 +1,338 @@
+/*
+ * 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 <unity/storage/provider/ProviderBase.h>  // TODO: Should not be needed
+
+#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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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-17 05:04:57 +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/qt/internal/RuntimeImpl.cpp'
--- src/qt/internal/RuntimeImpl.cpp	2016-11-21 13:29:39 +0000
+++ src/qt/internal/RuntimeImpl.cpp	2017-03-17 05:04:57 +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	2017-01-24 06:12:09 +0000
+++ src/qt/internal/StorageErrorImpl.cpp	2017-03-17 05:04:57 +0000
@@ -78,7 +78,6 @@
            || type == StorageError::Type::Cancelled
            || type == StorageError::Type::LogicError
            || type == StorageError::Type::InvalidArgument);
-    assert(!msg.isEmpty());
 
     message_ = msg;
 }
@@ -87,7 +86,6 @@
     : StorageErrorImpl(type)
 {
     assert(type == StorageError::Type::NotExists);
-    assert(!msg.isEmpty());
 
     message_ = msg;
     item_id_ = key;
@@ -104,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;
@@ -117,7 +112,6 @@
     : StorageErrorImpl(type)
 {
     assert(type == StorageError::Type::ResourceError);
-    assert(!msg.isEmpty());
 
     message_ = msg;
     error_code_ = error_code;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2017-03-07 10:23:24 +0000
+++ tests/CMakeLists.txt	2017-03-17 05:04:57 +0000
@@ -8,6 +8,7 @@
 set(unit_test_dirs
     registry
     local-client
+    local-provider
     remote-client
     remote-client-v1
     provider-AccountData

=== 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-17 05:04:57 +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-17 05:04:57 +0000
@@ -0,0 +1,1473 @@
+/*
+ * 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);
+}
+
+string const ROOT_DIR = TEST_DIR "/data";
+
+class LocalProviderTest : public ProviderFixture
+{
+protected:
+    void SetUp() override
+    {
+        boost::filesystem::remove_all(ROOT_DIR);
+        boost::filesystem::create_directory(ROOT_DIR);
+
+        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();
+    }
+
+    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()
+{
+    // 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();
+
+    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();
+
+    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();
+
+    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));
+    }
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+
+    auto file = job->item();
+    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
+
+    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
+    while (downloader->status() == Downloader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    downloader->close();
+    while (downloader->status() == Downloader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Downloader::Error, downloader->status()) << downloader->error().errorString().toStdString();
+
+    auto error = downloader->error();
+    EXPECT_EQ(qt::StorageError::LogicError, error.type());
+    cout << error.message().toStdString() << endl;
+    EXPECT_TRUE(boost::starts_with(error.message().toStdString(),
+                                   "finish() method called too early, file \""
+                                   + full_path + "\" has size 4460000 but only"));
+}
+
+TEST_F(LocalProviderTest, download_etag_mismatch)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    string const full_path = ROOT_DIR + "/foo.txt";
+    string cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+
+    auto file = job->item();
+
+    sleep(1);
+    cmd = string("touch ") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
+
+    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
+    while (downloader->status() != Downloader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    auto error = downloader->error();
+    EXPECT_EQ(qt::StorageError::Conflict, error.type());
+    EXPECT_EQ("download(): etag mismatch", error.message().toStdString());
+}
+
+TEST_F(LocalProviderTest, download_wrong_file_type)
+{
+    // We can't try a download for a directory via the client API, so we use the LocalDownloadJob directly.
+
+    auto p = make_shared<LocalProvider>();
+
+    string const dir = ROOT_DIR + "/dir";
+    ASSERT_EQ(0, mkdir(dir.c_str(), 0755));
+
+    try
+    {
+        LocalDownloadJob(p, dir, "some_etag");
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_EQ(string("InvalidArgumentException: download(): \"" + dir + "\" is not a file"), e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, download_no_permission)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    string const full_path = ROOT_DIR + "/foo.txt";
+    string cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
+
+    auto file = job->item();
+
+    ASSERT_EQ(0, chmod(full_path.c_str(), 0244));
+
+    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
+
+    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
+    while (downloader->status() != Downloader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    auto error = downloader->error();
+    EXPECT_EQ(qt::StorageError::ResourceError, error.type());
+    EXPECT_EQ(string("download(): : cannot open \"") + full_path + "\": Permission denied (QFileDevice::FileError = 5)",
+              error.message().toStdString());
+}
+
+TEST_F(LocalProviderTest, download_no_such_file)
+{
+    // We can't try a download for a non-existent file via the client API, so we use the LocalDownloadJob directly.
+
+    auto p = make_shared<LocalProvider>();
+
+    try
+    {
+        LocalDownloadJob(p, ROOT_DIR + "/no_such_file", "some_etag");
+        FAIL();
+    }
+    catch (provider::NotExistsException const&)
+    {
+    }
+}
+
+TEST_F(LocalProviderTest, update)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() == Uploader::Loading ||
+           uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Finished, uploader->status()) << uploader->error().errorString().toStdString();
+
+    file = uploader->item();
+    EXPECT_NE(old_etag, file.etag());
+    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
+}
+
+TEST_F(LocalProviderTest, update_empty)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    sleep(1);  // Make sure mtime changes.
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, 0));
+    {
+        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+        while (uploader->status() != Uploader::Ready)
+        {
+            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+        }
+    }
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    uploader->close();
+    while (uploader->status() != Uploader::Finished)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    file = uploader->item();
+    EXPECT_NE(old_etag, file.etag());
+    EXPECT_EQ(int64_t(0), file.sizeInBytes());
+}
+
+TEST_F(LocalProviderTest, update_cancel)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments / 2)
+            {
+                uploader->cancel();
+            }
+            else if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() != Uploader::Cancelled)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+}
+
+TEST_F(LocalProviderTest, update_file_touched_before_uploading)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    sleep(1);  // Make sure mtime changes.
+    cmd = string("touch ") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, 0));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    EXPECT_EQ("update(): etag mismatch", uploader->error().message().toStdString());
+}
+
+TEST_F(LocalProviderTest, update_file_touched_while_uploading)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments / 2)
+            {
+                sleep(1);
+                cmd = string("touch ") + full_path;
+                ASSERT_EQ(0, system(cmd.c_str()));
+            }
+            else if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status());
+    EXPECT_EQ("update(): etag mismatch", uploader->error().message().toStdString());
+}
+
+TEST_F(LocalProviderTest, update_ignore_etag_mismatch)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    sleep(1);  // Make sure mtime changes.
+    cmd = string("touch ") + full_path;
+    unique_ptr<Uploader> uploader(file.createUploader(Item::IgnoreConflict, 0));
+    {
+        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+        while (uploader->status() != Uploader::Ready)
+        {
+            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+        }
+    }
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    uploader->close();
+    while (uploader->status() != Uploader::Finished)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    file = uploader->item();
+    EXPECT_NE(old_etag, file.etag());
+    EXPECT_EQ(int64_t(0), file.sizeInBytes());
+}
+
+TEST_F(LocalProviderTest, update_close_too_soon)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments - 1)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status()) << uploader->error().errorString().toStdString();
+    EXPECT_EQ("LogicError: finish() method called too early, size was given as 22300 but only 21854 bytes were received",
+              uploader->error().errorString().toStdString());
+}
+
+TEST_F(LocalProviderTest, update_write_too_much)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
+    wait(job.get());
+    EXPECT_TRUE(job->isValid());
+
+    auto file = job->item();
+    auto old_etag = file.etag();
+
+    int const segments = 50;
+    // We write more than this many bytes below.
+    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments - 1));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status());
+    EXPECT_EQ("update(): received more than the expected number (22299) of bytes",
+              uploader->error().message().toStdString());
+}
+
+TEST_F(LocalProviderTest, upload_wrong_file_type)
+{
+    // We can't try an upload for a directory via the client API, so we use the LocalUploadJob directly.
+
+    auto p = make_shared<LocalProvider>();
+
+    string const dir = ROOT_DIR + "/dir";
+    ASSERT_EQ(0, mkdir(dir.c_str(), 0755));
+
+    try
+    {
+        LocalUploadJob(p, dir, 0, "");
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_EQ(string("InvalidArgumentException: update(): \"" + dir + "\" is not a file"), e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, upload_root_noperm)
+{
+    // Force an error in prepare_channels when creating temp file.
+
+    auto p = make_shared<LocalProvider>();
+
+    ASSERT_EQ(0, chmod(ROOT_DIR.c_str(), 0644));
+
+    try
+    {
+        LocalUploadJob(p, ROOT_DIR, "name", 0, true);
+        chmod(ROOT_DIR.c_str(), 0755);
+        FAIL();
+    }
+    catch (provider::ResourceException const& e)
+    {
+        EXPECT_EQ(string("ResourceException: create_file(): cannot create temp file \"") + ROOT_DIR
+                         + "/.storage-framework-%%%%-%%%%-%%%%-%%%%\": Invalid argument",
+                  e.what());
+    }
+    chmod(ROOT_DIR.c_str(), 0755);
+}
+
+TEST_F(LocalProviderTest, sanitize)
+{
+    // Force various errors in sanitize() for coverage.
+
+    auto p = make_shared<LocalProvider>();
+
+    try
+    {
+        LocalUploadJob(p, ROOT_DIR, "a/b", 0, true);
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_STREQ("InvalidArgumentException: create_file(): name \"a/b\" cannot contain a slash", e.what());
+    }
+
+    try
+    {
+        LocalUploadJob(p, ROOT_DIR, "..", 0, true);
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_STREQ("InvalidArgumentException: create_file(): invalid name: \"..\"", e.what());
+    }
+
+    try
+    {
+        LocalUploadJob(p, ROOT_DIR, ".storage-framework", 0, true);
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_STREQ("InvalidArgumentException: create_file(): names beginning with \".storage-framework\" are reserved",
+                     e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, throw_if_not_valid)
+{
+    // Make sure that we can't escape the root.
+
+    auto p = make_shared<LocalProvider>();
+
+    try
+    {
+        LocalUploadJob(p, ROOT_DIR + "/..", "a", 0, true);
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_EQ(string("InvalidArgumentException: create_file(): invalid id: \"") + ROOT_DIR + "/..\"", e.what());
+    }
+
+    try
+    {
+        LocalUploadJob(p, "/bin" , "a", 0, true);
+        FAIL();
+    }
+    catch (provider::InvalidArgumentException const& e)
+    {
+        EXPECT_STREQ("InvalidArgumentException: create_file(): invalid id: \"/bin\"", e.what());
+    }
+}
+
+TEST_F(LocalProviderTest, create_file)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto root = get_root(acc_);
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
+                                                  file_contents.size() * segments, "text/plain"));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() != Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    timer.start();
+    while (uploader->status() != Uploader::Finished)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    auto file = uploader->item();
+    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
+}
+
+TEST_F(LocalProviderTest, create_file_ignore_conflict)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    auto root = get_root(acc_);
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::IgnoreConflict,
+                                                  file_contents.size() * segments, "text/plain"));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() != Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    timer.start();
+    while (uploader->status() != Uploader::Finished)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    auto file = uploader->item();
+    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
+}
+
+TEST_F(LocalProviderTest, create_file_error_if_conflict)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto full_path = ROOT_DIR + "/foo.txt";
+    auto cmd = string("echo hello >") + full_path;
+    ASSERT_EQ(0, system(cmd.c_str()));
+
+    auto root = get_root(acc_);
+    int const segments = 50;
+    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
+                                                  file_contents.size() * segments, "text/plain"));
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    EXPECT_EQ(string("create_file(): \"") + full_path + "\" exists already",
+              uploader->error().message().toStdString());
+}
+
+TEST_F(LocalProviderTest, create_file_created_during_upload)
+{
+    using namespace unity::storage::qt;
+
+    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
+
+    auto root = get_root(acc_);
+    int const segments = 50;
+    string full_path = ROOT_DIR + "/foo.txt";
+    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
+                                                  file_contents.size() * segments, "text/plain"));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments / 2)
+            {
+                string cmd = "touch " + full_path;
+                ASSERT_EQ(0, system(cmd.c_str()));
+            }
+            else if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() != Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    timer.start();
+    while (uploader->status() != Uploader::Error)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    EXPECT_EQ(string("create_file(): \"") + full_path + "\" exists already",
+              uploader->error().message().toStdString());
+}
+
+int main(int argc, char** argv)
+{
+    setenv("LANG", "C", true);
+    setenv("SF_LOCAL_PROVIDER_ROOT", ROOT_DIR.c_str(), true);
+
+    // Test test fixture repeatedly creates and tears down the dbus connection.
+    // The provider calls g_file_new_for_path() which talks to the GVfs backend
+    // via dbus. If the dbus connection disappears, that causes GIO to send a
+    // a SIGTERM, killing the test.
+    // Setting GIO_USE_VFS variable to "local" disables sending the signal.
+    setenv("GIO_USE_VFS", "local", true);
+
+    QCoreApplication app(argc, argv);
+
+    ::testing::InitGoogleTest(&argc, argv);
+    int rc = RUN_ALL_TESTS();
+
+    // Process any pending events to avoid bogus leak reports from valgrind.
+    QCoreApplication::sendPostedEvents();
+    QCoreApplication::processEvents();
+
+    if (rc == 0)
+    {
+        boost::system::error_code ec;
+        boost::filesystem::remove_all(ROOT_DIR, ec);
+    }
+
+    return rc;
+}

=== added file 'tests/utils/env_var_guard.h'
--- tests/utils/env_var_guard.h	1970-01-01 00:00:00 +0000
+++ tests/utils/env_var_guard.h	2017-03-17 05:04:57 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <cassert>
+#include <cstdlib>
+#include <string>
+
+class EnvVarGuard final
+{
+public:
+    // Set environment variable 'name' to 'val'.
+    // To clear the variable, pass nullptr for 'val'.
+    // The destructor restores the original setting.
+    EnvVarGuard(char const* name, char const* val)
+        : name_(name)
+    {
+        assert(name && *name != '\0');
+        auto const old_val = getenv(name);
+        if ((was_set_ = old_val != nullptr))
+        {
+            old_value_ = old_val;
+        }
+        if (val)
+        {
+            setenv(name, val, true);
+        }
+        else
+        {
+            unsetenv(name);
+        }
+    }
+
+    // Restore the original setting.
+    ~EnvVarGuard()
+    {
+        if (was_set_)
+        {
+            setenv(name_.c_str(), old_value_.c_str(), true);
+        }
+        else
+        {
+            unsetenv(name_.c_str());
+        }
+    }
+
+    EnvVarGuard(const EnvVarGuard&) = delete;
+    EnvVarGuard& operator=(const EnvVarGuard&) = delete;
+
+private:
+    std::string name_;
+    std::string old_value_;
+    bool was_set_;
+};