1
=== modified file 'CMakeLists.txt'
2
--- CMakeLists.txt	2017-02-24 03:01:57 +0000
3
+++ CMakeLists.txt	2017-03-17 05:04:57 +0000
4
@@ -43,7 +43,7 @@
5
43
include_directories(include)
43
include_directories(include)
6
44
include_directories(${CMAKE_BINARY_DIR}/include)  # For generated headers
44
include_directories(${CMAKE_BINARY_DIR}/include)  # For generated headers
7
45
45
9
46
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC --std=c++11 -Wall -pedantic -Wextra -fvisibility=hidden")
46
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC --std=c++14 -Wall -pedantic -Wextra -fvisibility=hidden")
10
47
47
11
48
# Some additional warnings not included by the general flags set above.
48
# Some additional warnings not included by the general flags set above.
12
49
set(EXTRA_C_WARNINGS "-Wcast-align -Wcast-qual -Wformat -Wredundant-decls -Wswitch-default")
49
set(EXTRA_C_WARNINGS "-Wcast-align -Wcast-qual -Wformat -Wredundant-decls -Wswitch-default")
13
@@ -123,6 +123,7 @@
14
123
123
15
124
include(FindPkgConfig)
124
include(FindPkgConfig)
16
125
pkg_check_modules(APPARMOR_DEPS REQUIRED libapparmor)
125
pkg_check_modules(APPARMOR_DEPS REQUIRED libapparmor)
17
126
pkg_check_modules(GIO_DEPS REQUIRED gio-2.0 gio-unix-2.0)
18
126
pkg_check_modules(GLIB_DEPS REQUIRED glib-2.0)
127
pkg_check_modules(GLIB_DEPS REQUIRED glib-2.0)
19
127
pkg_check_modules(ONLINEACCOUNTS_DEPS REQUIRED OnlineAccountsQt)
128
pkg_check_modules(ONLINEACCOUNTS_DEPS REQUIRED OnlineAccountsQt)
20
128
129
21
@@ -137,6 +138,7 @@
22
137
138
23
138
enable_coverage_report(
139
enable_coverage_report(
24
139
    TARGETS
140
    TARGETS
25
141
        local-provider-lib
26
140
        qt-client-lib-common
142
        qt-client-lib-common
27
141
        storage-framework-common-internal
143
        storage-framework-common-internal
28
142
        storage-framework-qt-client
144
        storage-framework-qt-client
29
@@ -145,6 +147,7 @@
30
145
        sf-provider-objects
147
        sf-provider-objects
31
146
        storage-framework-provider
148
        storage-framework-provider
32
147
        storage-framework-registry
149
        storage-framework-registry
33
150
        storage-provider-local
34
148
    FILTER
151
    FILTER
35
149
        ${CMAKE_SOURCE_DIR}/tests/*
152
        ${CMAKE_SOURCE_DIR}/tests/*
36
150
        ${CMAKE_BINARY_DIR}/*
153
        ${CMAKE_BINARY_DIR}/*
37
151
154
38
=== modified file 'debian/control.in'
39
--- debian/control.in	2016-12-12 02:18:21 +0000
40
+++ debian/control.in	2017-03-17 05:04:57 +0000
41
@@ -2,7 +2,7 @@
42
2
Section: libs
2
Section: libs
43
3
Priority: optional
3
Priority: optional
44
4
Maintainer: Ubuntu Core Developers <ubuntu-devel-discuss@lists.ubuntu.com>
4
Maintainer: Ubuntu Core Developers <ubuntu-devel-discuss@lists.ubuntu.com>
46
5
Standards-Version: 3.9.6
5
Standards-Version: 3.9.7
47
6
Build-Depends: cmake,
6
Build-Depends: cmake,
48
7
               cmake-extras (>= 0.10),
7
               cmake-extras (>= 0.10),
49
8
               debhelper (>= 9),
8
               debhelper (>= 9),
50
@@ -58,6 +58,7 @@
51
58
         online-accounts-daemon,
58
         online-accounts-daemon,
52
59
Description: Registry for the Storage Framework
59
Description: Registry for the Storage Framework
53
60
 DBus service that provides access to provider account information.
60
 DBus service that provides access to provider account information.
54
61
 Includes a local storage provider.
55
61
62
56
62
Package: libstorage-framework-qt-client-2-0
63
Package: libstorage-framework-qt-client-2-0
57
63
Architecture: any
64
Architecture: any
58
64
65
59
=== modified file 'debian/storage-framework-registry.install'
60
--- debian/storage-framework-registry.install	2016-11-21 04:37:37 +0000
61
+++ debian/storage-framework-registry.install	2017-03-17 05:04:57 +0000
62
@@ -1,2 +1,4 @@
63
1
usr/lib/*/*/storage-framework-registry
1
usr/lib/*/*/storage-framework-registry
64
2
usr/share/dbus-1/services/com.canonical.StorageFramework.Registry.service
2
usr/share/dbus-1/services/com.canonical.StorageFramework.Registry.service
65
3
usr/lib/*/*/storage-provider-local
66
4
usr/share/dbus-1/services/com.canonical.StorageFramework.Provider.Local.service
67
3
5
68
=== added file 'include/unity/storage/internal/gobj_memory.h'
69
--- include/unity/storage/internal/gobj_memory.h	1970-01-01 00:00:00 +0000
70
+++ include/unity/storage/internal/gobj_memory.h	2017-03-17 05:04:57 +0000
71
@@ -0,0 +1,212 @@
72
1
/*
73
2
 * Copyright (C) 2013 Canonical Ltd.
74
3
 *
75
4
 * This program is free software: you can redistribute it and/or modify
76
5
 * it under the terms of the GNU Lesser General Public License version 3 as
77
6
 * published by the Free Software Foundation.
78
7
 *
79
8
 * This program is distributed in the hope that it will be useful,
80
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
81
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
82
11
 * GNU Lesser General Public License for more details.
83
12
 *
84
13
 * You should have received a copy of the GNU Lesser General Public License
85
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
86
15
 *
87
16
 * Authored by: Jussi Pakkanen <jussi.pakkanen@canonical.com>
88
17
 */
89
18
90
19
#pragma once
91
20
92
21
#include <stdexcept>
93
22
94
23
#pragma GCC diagnostic push
95
24
#pragma GCC diagnostic ignored "-Wold-style-cast"
96
25
#pragma GCC diagnostic ignored "-Wcast-qual"
97
26
#include <glib-object.h>
98
27
99
28
namespace unity
100
29
{
101
30
102
31
namespace storage
103
32
{
104
33
105
34
namespace internal
106
35
{
107
36
108
37
/**
109
38
 * This class is meant for automatically managing the lifetime of C objects derived
110
39
 * from gobject. Its API perfectly mirrors the API of unique_ptr except that you
111
40
 * can't define your own deleter function as it is always g_object_unref.
112
41
 *
113
42
 * API/ABI stability is not guaranteed. If you need to pass the object across an ABI
114
43
 * boundary, pass the plain gobject.
115
44
 *
116
45
 * This is how you would use gobj_ptr 99% of the time:
117
46
 *
118
47
 * gobj_ptr<GSomeType> o(g_some_type_new(...));
119
48
 *
120
49
 * More specifically, the object will decrement the gobject reference count
121
50
 * of the object it points to when it goes out of scope. It will never increment it.
122
51
 * Thus you should only assign to it when already holding a reference. gobj_ptr
123
52
 * will then take ownership of that particular reference.
124
53
 *
125
54
 * Floating gobjects can not be put in this container as they are meant to be put
126
55
 * into native gobject aware containers immediately upon construction. Trying to insert
127
56
 * a floating gobject into a gobj_ptr will throw an invalid_argument exception. To
128
57
 * prevent accidental memory leaks, the floating gobject is unreffed in this case.
129
58
 */
130
59
template <typename T>
131
60
class gobj_ptr final
132
61
{
133
62
private:
134
63
    T* u;
135
64
136
65
    void validate_float(T* t)
137
66
    {
138
67
        if (t != nullptr && g_object_is_floating(G_OBJECT(t)))
139
68
        {
140
69
            // LCOV_EXCL_START  // False negative from gcovr.
141
70
            throw std::invalid_argument("Tried to add a floating gobject into a gobj_ptr.");
142
71
            // LCOV_EXCL_STOP
143
72
        }
144
73
    }
145
74
146
75
public:
147
76
    typedef T element_type;
148
77
    typedef T* pointer;
149
78
    typedef decltype(g_object_unref) deleter_type;
150
79
151
80
    constexpr gobj_ptr() noexcept : u(nullptr)
152
81
    {
153
82
    }
154
83
    explicit gobj_ptr(T* t)
155
84
        : u(t)
156
85
    {
157
86
        // What should we do if validate throws? Unreffing unknown objs
158
87
        // is dodgy but not unreffing runs the risk of
159
88
        // memory leaks. Currently unrefs as u is destroyed
160
89
        // when this exception is thrown.
161
90
        validate_float(t);
162
91
    }
163
92
    constexpr gobj_ptr(std::nullptr_t) noexcept : u(nullptr){};
164
93
    gobj_ptr(gobj_ptr&& o) noexcept
165
94
    {
166
95
        u = o.u;
167
96
        o.u = nullptr;
168
97
    }
169
98
    gobj_ptr(const gobj_ptr& o)
170
99
        : u(nullptr)
171
100
    {
172
101
        *this = o;
173
102
    }
174
103
    gobj_ptr& operator=(const gobj_ptr& o)
175
104
    {
176
105
        if (o.u != nullptr)
177
106
        {
178
107
            g_object_ref(o.u);
179
108
        }
180
109
        reset(o.u);
181
110
        return *this;
182
111
    }
183
112
    ~gobj_ptr()
184
113
    {
185
114
        reset();
186
115
    }
187
116
188
117
    deleter_type& get_deleter() noexcept
189
118
    {
190
119
        return g_object_unref;
191
120
    }
192
121
    deleter_type& get_deleter() const noexcept
193
122
    {
194
123
        return g_object_unref;
195
124
    }
196
125
197
126
    void swap(gobj_ptr<T>& o) noexcept
198
127
    {
199
128
        T* tmp = u;
200
129
        u = o.u;
201
130
        o.u = tmp;
202
131
    }
203
132
    void reset(pointer p = pointer())
204
133
    {
205
134
        if (u != nullptr)
206
135
        {
207
136
            g_object_unref(G_OBJECT(u));
208
137
            u = nullptr;
209
138
        }
210
139
        // Same throw dilemma as in pointer constructor.
211
140
        u = p;
212
141
        validate_float(p);
213
142
    }
214
143
215
144
    T* release() noexcept
216
145
    {
217
146
        T* r = u;
218
147
        u = nullptr;
219
148
        return r;
220
149
    }
221
150
    T* get() const noexcept
222
151
    {
223
152
        return u;
224
153
    }
225
154
226
155
    T& operator*() const
227
156
    {
228
157
        return *u;
229
158
    }
230
159
    T* operator->() const noexcept
231
160
    {
232
161
        return u;
233
162
    }
234
163
    explicit operator bool() const noexcept
235
164
    {
236
165
        return u != nullptr;
237
166
    }
238
167
239
168
    gobj_ptr& operator=(gobj_ptr&& o) noexcept
240
169
    {
241
170
        reset();
242
171
        u = o.u;
243
172
        o.u = nullptr;
244
173
        return *this;
245
174
    }
246
175
    gobj_ptr& operator=(std::nullptr_t) noexcept
247
176
    {
248
177
        reset();
249
178
        return *this;
250
179
    }
251
180
    bool operator==(const gobj_ptr<T>& o) const noexcept
252
181
    {
253
182
        return u == o.u;
254
183
    }
255
184
    bool operator!=(const gobj_ptr<T>& o) const noexcept
256
185
    {
257
186
        return u != o.u;
258
187
    }
259
188
    bool operator<(const gobj_ptr<T>& o) const noexcept
260
189
    {
261
190
        return u < o.u;
262
191
    }
263
192
    bool operator<=(const gobj_ptr<T>& o) const noexcept
264
193
    {
265
194
        return u <= o.u;
266
195
    }
267
196
    bool operator>(const gobj_ptr<T>& o) const noexcept
268
197
    {
269
198
        return u > o.u;
270
199
    }
271
200
    bool operator>=(const gobj_ptr<T>& o) const noexcept
272
201
    {
273
202
        return u >= o.u;
274
203
    }
275
204
};
276
205
277
206
}  // namespace internal
278
207
279
208
}  // namespace storage
280
209
281
210
}  // namespace unity
282
211
283
212
#pragma GCC diagnostic pop
284
0
213
285
=== modified file 'include/unity/storage/provider/Exceptions.h'
286
--- include/unity/storage/provider/Exceptions.h	2017-01-27 09:28:03 +0000
287
+++ include/unity/storage/provider/Exceptions.h	2017-03-17 05:04:57 +0000
288
@@ -95,7 +95,7 @@
289
95
};
95
};
290
96
96
291
97
/**
97
/**
293
98
\brief Indicates that an upload detected a version mismatch.
98
\brief Indicates that an upload or download detected a version mismatch.
294
99
*/
99
*/
295
100
class UNITY_STORAGE_EXPORT ConflictException : public StorageException
100
class UNITY_STORAGE_EXPORT ConflictException : public StorageException
296
101
{
101
{
297
102
102
298
=== modified file 'src/CMakeLists.txt'
299
--- src/CMakeLists.txt	2016-11-07 04:49:34 +0000
300
+++ src/CMakeLists.txt	2017-03-17 05:04:57 +0000
301
@@ -2,3 +2,4 @@
302
2
add_subdirectory(provider)
2
add_subdirectory(provider)
303
3
add_subdirectory(qt)
3
add_subdirectory(qt)
304
4
add_subdirectory(registry)
4
add_subdirectory(registry)
305
5
add_subdirectory(local-provider)
306
5
6
307
=== added directory 'src/local-provider'
308
=== added file 'src/local-provider/CMakeLists.txt'
309
--- src/local-provider/CMakeLists.txt	1970-01-01 00:00:00 +0000
310
+++ src/local-provider/CMakeLists.txt	2017-03-17 05:04:57 +0000
311
@@ -0,0 +1,43 @@
312
1
add_definitions(-DBOOST_THREAD_VERSION=4)
313
2
314
3
add_library(local-provider-lib STATIC
315
4
    LocalDownloadJob.cpp
316
5
    LocalProvider.cpp
317
6
    LocalUploadJob.cpp
318
7
    utils.cpp
319
8
)
320
9
321
10
target_include_directories(local-provider-lib PRIVATE
322
11
    ${Qt5Network_INCLUDE_DIRS}
323
12
    ${GLIB_DEPS_INCLUDE_DIRS}
324
13
    ${GIO_DEPS_INCLUDE_DIRS}
325
14
)
326
15
327
16
set_target_properties(local-provider-lib PROPERTIES
328
17
    AUTOMOC TRUE
329
18
    POSITION_INDEPENDENT_CODE TRUE
330
19
)
331
20
332
21
add_executable(storage-provider-local
333
22
    main.cpp
334
23
)
335
24
336
25
target_link_libraries(storage-provider-local
337
26
    local-provider-lib
338
27
    storage-framework-provider
339
28
    Qt5::Network
340
29
    ${GLIB_DEPS_LIBRARIES}
341
30
    ${GIO_DEPS_LIBRARIES}
342
31
)
343
32
344
33
install(
345
34
    TARGETS storage-provider-local
346
35
    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}
347
36
)
348
37
349
38
configure_file(com.canonical.StorageFramework.Provider.Local.service.in com.canonical.StorageFramework.Provider.Local.service)
350
39
351
40
install(
352
41
    FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.StorageFramework.Provider.Local.service
353
42
    DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services
354
43
)
355
0
44
356
=== added file 'src/local-provider/LocalDownloadJob.cpp'
357
--- src/local-provider/LocalDownloadJob.cpp	1970-01-01 00:00:00 +0000
358
+++ src/local-provider/LocalDownloadJob.cpp	2017-03-17 05:04:57 +0000
359
@@ -0,0 +1,179 @@
360
1
/*
361
2
 * Copyright (C) 2017 Canonical Ltd
362
3
 *
363
4
 * This program is free software: you can redistribute it and/or modify
364
5
 * it under the terms of the GNU Lesser General Public License version 3 as
365
6
 * published by the Free Software Foundation.
366
7
 *
367
8
 * This program is distributed in the hope that it will be useful,
368
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
369
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
370
11
 * GNU Lesser General Public License for more details.
371
12
 *
372
13
 * You should have received a copy of the GNU Lesser General Public License
373
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
374
15
 *
375
16
 * Authors: Michi Henning <michi.henning@canonical.com>
376
17
 */
377
18
378
19
#include "LocalDownloadJob.h"
379
20
380
21
#include "LocalProvider.h"
381
22
#include "utils.h"
382
23
#include <unity/storage/internal/safe_strerror.h>
383
24
#include <unity/storage/provider/Exceptions.h>
384
25
385
26
using namespace unity::storage::provider;
386
27
using namespace std;
387
28
388
29
static int next_download_id = 0;
389
30
390
31
string const method = "download()";
391
32
392
33
LocalDownloadJob::LocalDownloadJob(shared_ptr<LocalProvider> const& provider,
393
34
                                   string const& item_id,
394
35
                                   string const& match_etag)
395
36
    : DownloadJob(to_string(++next_download_id))
396
37
    , provider_(provider)
397
38
    , item_id_(item_id)
398
39
{
399
40
    using namespace boost::filesystem;
400
41
401
42
    // Sanitize parameters.
402
43
    provider_->throw_if_not_valid(method, item_id_);
403
44
    try
404
45
    {
405
46
        auto st = status(item_id_);
406
47
        if (!is_regular_file(st))
407
48
        {
408
49
            throw InvalidArgumentException(method + ": \"" + item_id_ + "\" is not a file");
409
50
        }
410
51
    }
411
52
    // LCOV_EXCL_START  // Too small a window to hit with a test.
412
53
    catch (filesystem_error const& e)
413
54
    {
414
55
        throw_storage_exception(method, e);
415
56
    }
416
57
    // LCOV_EXCL_STOP
417
58
    if (!match_etag.empty())
418
59
    {
419
60
        int64_t mtime = get_mtime_nsecs(method, item_id_);
420
61
        if (to_string(mtime) != match_etag)
421
62
        {
422
63
            throw ConflictException(method + ": etag mismatch");
423
64
        }
424
65
    }
425
66
426
67
    // Make input file ready.
427
68
    QString filename = QString::fromStdString(item_id);
428
69
    file_.reset(new QFile(filename));
429
70
    if (!file_->open(QIODevice::ReadOnly))
430
71
    {
431
72
        throw_storage_exception(method,
432
73
                                ": cannot open \"" + item_id + "\": " + file_->errorString().toStdString(),
433
74
                                file_->error());
434
75
    }
435
76
    bytes_to_write_ = file_->size();
436
77
437
78
    // Make write socket ready.
438
79
    int dup_fd = dup(write_socket());
439
80
    if (dup_fd == -1)
440
81
    {
441
82
        // LCOV_EXCL_START
442
83
        string msg = "LocalDownloadJob(): dup() failed: " + unity::storage::internal::safe_strerror(errno);
443
84
        throw ResourceException(msg, errno);
444
85
        // LCOV_EXCL_STOP
445
86
    }
446
87
    write_socket_.setSocketDescriptor(dup_fd, QLocalSocket::ConnectedState, QIODevice::WriteOnly);
447
88
    connect(&write_socket_, &QIODevice::bytesWritten, this, &LocalDownloadJob::on_bytes_written);
448
89
449
90
    // Kick off the read-write cycle.
450
91
    QMetaObject::invokeMethod(this, "read_and_write_chunk", Qt::QueuedConnection);
451
92
}
452
93
453
94
LocalDownloadJob::~LocalDownloadJob() = default;
454
95
455
96
boost::future<void> LocalDownloadJob::cancel()
456
97
{
457
98
    disconnect(&write_socket_, nullptr, this, nullptr);
458
99
    write_socket_.abort();
459
100
    file_->close();
460
101
    return boost::make_ready_future();
461
102
}
462
103
463
104
boost::future<void> LocalDownloadJob::finish()
464
105
{
465
106
    if (bytes_to_write_ > 0)
466
107
    {
467
108
        auto file_size = file_->size();
468
109
        auto written = file_size - bytes_to_write_;
469
110
        string msg = "finish() method called too early, file \"" + item_id_ + "\" has size "
470
111
                     + to_string(file_size) + " but only " + to_string(written) + " bytes were consumed";
471
112
        cancel();
472
113
        return boost::make_exceptional_future<void>(LogicException(msg));
473
114
    }
474
115
    // LCOV_EXCL_START
475
116
    // Not reachable because we call report_complete() in read_and_write_chunk().
476
117
    return boost::make_ready_future();
477
118
    // LCOV_EXCL_STOP
478
119
}
479
120
480
121
void LocalDownloadJob::on_bytes_written(qint64 bytes)
481
122
{
482
123
    bytes_to_write_ -= bytes;
483
124
    assert(bytes_to_write_ >= 0);
484
125
    read_and_write_chunk();
485
126
}
486
127
487
128
void LocalDownloadJob::read_and_write_chunk()
488
129
{
489
130
    static qint64 constexpr READ_SIZE = 64 * 1024;
490
131
491
132
    if (bytes_to_write_ == 0)
492
133
    {
493
134
        file_->close();
494
135
        write_socket_.close();
495
136
        report_complete();
496
137
        return;
497
138
    }
498
139
499
140
    QByteArray buf;
500
141
    buf.resize(READ_SIZE);
501
142
    auto bytes_read = file_->read(buf.data(), buf.size());
502
143
    try
503
144
    {
504
145
        if (bytes_read == -1)
505
146
        {
506
147
            // LCOV_EXCL_START
507
148
            string msg = string("\"") + item_id_ + "\": read error: " + file_->errorString().toStdString();
508
149
            throw_storage_exception(method, msg, file_->error());
509
150
            // LCOV_EXCL_STOP
510
151
        }
511
152
        buf.resize(bytes_read);
512
153
513
154
        auto bytes_written = write_socket_.write(buf);
514
155
        if (bytes_written == -1)
515
156
        {
516
157
            // LCOV_EXCL_START
517
158
            string msg = string("\"") + item_id_ + "\": socket error: " + write_socket_.errorString().toStdString();
518
159
            throw_storage_exception(method, msg, write_socket_.error());
519
160
            // LCOV_EXCL_STOP
520
161
        }
521
162
        else if (bytes_written != bytes_read)
522
163
        {
523
164
            // LCOV_EXCL_START
524
165
            string msg = string("\"") + item_id_ + "\": socket write error, requested " + to_string(bytes_read)
525
166
                         + " B, but wrote only " + to_string(bytes_written) + " B.";
526
167
            throw_storage_exception(method, msg, QLocalSocket::UnknownSocketError);
527
168
            // LCOV_EXCL_STOP
528
169
        }
529
170
    }
530
171
    // LCOV_EXCL_START
531
172
    catch (std::exception const&)
532
173
    {
533
174
        write_socket_.abort();
534
175
        file_->close();
535
176
        report_error(current_exception());
536
177
    }
537
178
    // LCOV_EXCL_STOP
538
179
}
539
0
180
540
=== added file 'src/local-provider/LocalDownloadJob.h'
541
--- src/local-provider/LocalDownloadJob.h	1970-01-01 00:00:00 +0000
542
+++ src/local-provider/LocalDownloadJob.h	2017-03-17 05:04:57 +0000
543
@@ -0,0 +1,54 @@
544
1
/*
545
2
 * Copyright (C) 2017 Canonical Ltd
546
3
 *
547
4
 * This program is free software: you can redistribute it and/or modify
548
5
 * it under the terms of the GNU Lesser General Public License version 3 as
549
6
 * published by the Free Software Foundation.
550
7
 *
551
8
 * This program is distributed in the hope that it will be useful,
552
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
553
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
554
11
 * GNU Lesser General Public License for more details.
555
12
 *
556
13
 * You should have received a copy of the GNU Lesser General Public License
557
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
558
15
 *
559
16
 * Authors: Michi Henning <michi.henning@canonical.com>
560
17
 */
561
18
562
19
#pragma once
563
20
564
21
#include <unity/storage/provider/DownloadJob.h>
565
22
566
23
#pragma GCC diagnostic push
567
24
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
568
25
#pragma GCC diagnostic ignored "-Wswitch-default"
569
26
#include <QFile>
570
27
#include <QLocalSocket>
571
28
#pragma GCC diagnostic pop
572
29
573
30
class LocalProvider;
574
31
575
32
class LocalDownloadJob : public QObject, public unity::storage::provider::DownloadJob
576
33
{
577
34
    Q_OBJECT
578
35
public:
579
36
    LocalDownloadJob(std::shared_ptr<LocalProvider> const& provider,
580
37
                     std::string const& item_id,
581
38
                     std::string const& match_etag);
582
39
    virtual ~LocalDownloadJob();
583
40
584
41
    virtual boost::future<void> cancel() override;
585
42
    virtual boost::future<void> finish() override;
586
43
587
44
private Q_SLOTS:
588
45
    void on_bytes_written(qint64 bytes);
589
46
    void read_and_write_chunk();
590
47
591
48
private:
592
49
    std::shared_ptr<LocalProvider> const provider_;
593
50
    std::string const item_id_;
594
51
    std::unique_ptr<QFile> file_;
595
52
    QLocalSocket write_socket_;
596
53
    int64_t bytes_to_write_;
597
54
};
598
0
55
599
=== added file 'src/local-provider/LocalProvider.cpp'
600
--- src/local-provider/LocalProvider.cpp	1970-01-01 00:00:00 +0000
601
+++ src/local-provider/LocalProvider.cpp	2017-03-17 05:04:57 +0000
602
@@ -0,0 +1,586 @@
603
1
/*
604
2
 * Copyright (C) 2017 Canonical Ltd
605
3
 *
606
4
 * This program is free software: you can redistribute it and/or modify
607
5
 * it under the terms of the GNU Lesser General Public License version 3 as
608
6
 * published by the Free Software Foundation.
609
7
 *
610
8
 * This program is distributed in the hope that it will be useful,
611
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
612
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
613
11
 * GNU Lesser General Public License for more details.
614
12
 *
615
13
 * You should have received a copy of the GNU Lesser General Public License
616
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
617
15
 *
618
16
 * Authors: Michi Henning <michi.henning@canonical.com>
619
17
 */
620
18
621
19
#include "LocalProvider.h"
622
20
623
21
#include "LocalDownloadJob.h"
624
22
#include "LocalUploadJob.h"
625
23
#include "utils.h"
626
24
627
25
#include <unity/storage/internal/gobj_memory.h>
628
26
#include <unity/storage/provider/Exceptions.h>
629
27
630
28
#include <boost/algorithm/string.hpp>
631
29
632
30
#pragma GCC diagnostic push
633
31
#pragma GCC diagnostic ignored "-Wold-style-cast"
634
32
#include <gio/gio.h>
635
33
#include <glib.h>
636
34
#pragma GCC diagnostic pop
637
35
638
36
using namespace unity::storage::provider;
639
37
using namespace std;
640
38
641
39
namespace
642
40
{
643
41
644
42
// Return the root directory where we store files.
645
43
// If SF_LOCAL_PROVIDER_ROOT is set (used for testing), any files are created
646
44
// directly under the root. E.g., if we do root.createFile("foo.txt", ...), the file
647
45
// will be created as ${SF_LOCAL_PROVIDER_ROOT/foo.txt. SF_LOCAL_PROVIDER_ROOT must
648
46
// be a pre-existing directory.
649
47
//
650
48
// Otherwise, the root is determined by SNAP_USER_COMMON or, if that is not set,
651
49
// by XDG_DATA_HOME. Either way, files are created in a storage-framework/local
652
50
// subdirectory. E.g., if SNAP_USER_COMMON or XDG_DATA_HOME is set to "/tmp" and
653
51
// we do root.createFile("foo.txt", ...), the file will be created as
654
52
// /tmp/storage-framework/local/foo.txt. If /tmp/storage-framework/local does not exist,
655
53
// the directory will be created.
656
54
657
55
string get_root_dir(string const& method)
658
56
{
659
57
    using namespace boost::filesystem;
660
58
661
59
    char const* dir = getenv("SF_LOCAL_PROVIDER_ROOT");
662
60
    if (dir && *dir != '\0')
663
61
    {
664
62
        boost::system::error_code ec;
665
63
        if (!exists(dir, ec) || !is_directory(dir, ec))
666
64
        {
667
65
            string msg = method + ": Environment variable SF_LOCAL_PROVIDER_ROOT must denote an existing directory";
668
66
            throw InvalidArgumentException(msg);
669
67
        }
670
68
        return dir;
671
69
    }
672
70
673
71
    string data_dir;
674
72
    dir = getenv("SNAP_USER_COMMON");
675
73
    if (dir && *dir != '\0')
676
74
    {
677
75
        data_dir = dir;
678
76
    }
679
77
    else
680
78
    {
681
79
        data_dir = g_get_user_data_dir();  // Never fails.
682
80
    }
683
81
    data_dir += "/storage-framework/local";
684
82
685
83
    try
686
84
    {
687
85
        create_directories(data_dir);
688
86
    }
689
87
    catch (filesystem_error const& e)
690
88
    {
691
89
        throw_storage_exception(method, e);
692
90
    }
693
91
694
92
    return data_dir;
695
93
}
696
94
697
95
// Copy a file or directory (recursively). Ignore anything that has the temp file prefix
698
96
// or is not a file or directory.
699
97
700
98
void copy_recursively(boost::filesystem::path const& source, boost::filesystem::path const& target)
701
99
{
702
100
    using namespace boost::filesystem;
703
101
704
102
    if (is_reserved_path(source))
705
103
    {
706
104
        return;  // Don't copy temporary directories.
707
105
    }
708
106
709
107
    auto s = status(source);
710
108
    if (is_regular_file(s))
711
109
    {
712
110
        copy_file(source, target);
713
111
    }
714
112
    else if (is_directory(s))
715
113
    {
716
114
        copy_directory(source, target);  // Poorly named in boost; this creates the target dir without recursion
717
115
        for (directory_iterator it(source); it != directory_iterator(); ++it)
718
116
        {
719
117
            path source_entry = it->path();
720
118
            path target_entry = target;
721
119
            target_entry /= source_entry.filename();
722
120
            copy_recursively(source_entry, target_entry);
723
121
        }
724
122
    }
725
123
    else
726
124
    {
727
125
        // Ignore everything that's not a directory or file.
728
126
    }
729
127
}
730
128
731
129
// Convert nanoseconds since the epoch into ISO 8601 date-time.
732
130
733
131
string make_iso_date(int64_t nsecs_since_epoch)
734
132
{
735
133
    static char const* const FMT = "%Y-%m-%dT%TZ";  // ISO 8601, no fractional seconds.
736
134
737
135
    struct tm time;
738
136
    time_t secs_since_epoch = nsecs_since_epoch / 1000000000;
739
137
    gmtime_r(&secs_since_epoch, &time);
740
138
741
139
    char buf[128];
742
140
    strftime(buf, sizeof(buf), FMT, &time);
743
141
    return buf;
744
142
}
745
143
746
144
string get_content_type(string const& filename)
747
145
{
748
146
    using namespace unity::storage::internal;
749
147
750
148
    static string const unknown_content_type = "application/octet-stream";
751
149
752
150
    gobj_ptr<GFile> file(g_file_new_for_path(filename.c_str()));
753
151
    assert(file);  // Cannot fail according to doc.
754
152
755
153
    GError* err = nullptr;
756
154
    gobj_ptr<GFileInfo> full_info(g_file_query_info(file.get(),
757
155
                                                    G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,
758
156
                                                    G_FILE_QUERY_INFO_NONE,
759
157
                                                    /* cancellable */ NULL,
760
158
                                                    &err));
761
159
    if (!full_info)
762
160
    {
763
161
        return unknown_content_type;  // LCOV_EXCL_LINE
764
162
    }
765
163
766
164
    string content_type = g_file_info_get_attribute_string(full_info.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE);
767
165
    if (content_type.empty())
768
166
    {
769
167
        return unknown_content_type;  // LCOV_EXCL_LINE
770
168
    }
771
169
    return content_type;
772
170
}
773
171
774
172
// Simple wrapper template that deals with exception handling so we don't
775
173
// have to repeat ourselves endlessly in the various lambdas below.
776
174
// The auto deduction of the return type requires C++ 14.
777
175
778
176
template<typename F>
779
177
auto invoke_async(string const& method, F& functor)
780
178
{
781
179
    auto lambda = [method, functor]
782
180
    {
783
181
        try
784
182
        {
785
183
            return functor();
786
184
        }
787
185
        catch (StorageException const&)
788
186
        {
789
187
            throw;
790
188
        }
791
189
        catch (boost::filesystem::filesystem_error const& e)
792
190
        {
793
191
            throw_storage_exception(method, e);
794
192
        }
795
193
        // LCOV_EXCL_START
796
194
        catch (std::exception const& e)
797
195
        {
798
196
            throw boost::enable_current_exception(UnknownException(e.what()));
799
197
        }
800
198
        // LCOV_EXCL_STOP
801
199
    };
802
200
    // TODO: boost::async is potentially expensive for some operations. Consider boost::asio thread pool?
803
201
    return boost::async(boost::launch::async, lambda);
804
202
}
805
203
806
204
}  // namespace
807
205
808
206
LocalProvider::LocalProvider()
809
207
    : root_(boost::filesystem::canonical(get_root_dir("LocalProvider()")))
810
208
{
811
209
}
812
210
813
211
LocalProvider::~LocalProvider() = default;
814
212
815
213
boost::future<ItemList> LocalProvider::roots(vector<string> const& /* keys */, Context const& /* context */)
816
214
{
817
215
    vector<Item> roots{ make_item("roots()", root_, status(root_)) };
818
216
    return boost::make_ready_future(roots);
819
217
}
820
218
821
219
boost::future<tuple<ItemList, string>> LocalProvider::list(string const& item_id,
822
220
                                                           string const& page_token,
823
221
                                                           vector<string> const& /* keys */,
824
222
                                                           Context const& /* context */)
825
223
{
826
224
    string const method = "list()";
827
225
828
226
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
829
227
    auto do_list = [This, method, item_id, page_token]
830
228
    {
831
229
        using namespace boost::filesystem;
832
230
833
231
        This->throw_if_not_valid(method, item_id);
834
232
        vector<Item> items;
835
233
        for (directory_iterator it(item_id); it != directory_iterator(); ++it)
836
234
        {
837
235
            auto dirent = *it;
838
236
            auto path = dirent.path();
839
237
            if (is_reserved_path(path))
840
238
            {
841
239
                continue;  // Hide temp files that we create during copy() and move().
842
240
            }
843
241
            Item i;
844
242
            try
845
243
            {
846
244
                auto st = dirent.status();
847
245
                i = This->make_item(method, path, st);
848
246
                items.push_back(i);
849
247
            }
850
248
            catch (std::exception const&)
851
249
            {
852
250
                // We ignore weird errors (such as entries that are not files or folders).
853
251
            }
854
252
        }
855
253
        return tuple<ItemList, string>(items, "");
856
254
    };
857
255
858
256
    return invoke_async(method, do_list);
859
257
}
860
258
861
259
boost::future<ItemList> LocalProvider::lookup(string const& parent_id,
862
260
                                              string const& name,
863
261
                                              vector<string> const& /* keys */,
864
262
                                              Context const& /* context */)
865
263
{
866
264
    string const method = "lookup()";
867
265
868
266
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
869
267
    auto do_lookup = [This, method, parent_id, name]
870
268
    {
871
269
        using namespace boost::filesystem;
872
270
873
271
        This->throw_if_not_valid(method, parent_id);
874
272
        auto sanitized_name = sanitize(method, name);
875
273
        path p = parent_id;
876
274
        p /= sanitized_name;
877
275
        This->throw_if_not_valid(method, p.native());
878
276
        auto st = status(p);
879
277
        return vector<Item>{ This->make_item(method, p, st) };
880
278
    };
881
279
882
280
    return invoke_async(method, do_lookup);
883
281
}
884
282
885
283
boost::future<Item> LocalProvider::metadata(string const& item_id,
886
284
                                            vector<string> const& /* keys */,
887
285
                                            Context const& /* context */)
888
286
{
889
287
    string const method = "metadata()";
890
288
891
289
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
892
290
    auto do_metadata = [This, method, item_id]
893
291
    {
894
292
        using namespace boost::filesystem;
895
293
896
294
        This->throw_if_not_valid(method, item_id);
897
295
        path p = item_id;
898
296
        auto st = status(p);
899
297
        return This->make_item(method, p, st);
900
298
    };
901
299
902
300
    return invoke_async(method, do_metadata);
903
301
}
904
302
905
303
boost::future<Item> LocalProvider::create_folder(string const& parent_id,
906
304
                                                 string const& name,
907
305
                                                 vector<string> const& /* keys */,
908
306
                                                 Context const& /* context */)
909
307
{
910
308
    string const method = "create_folder()";
911
309
912
310
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
913
311
    auto do_create = [This, method, parent_id, name]
914
312
    {
915
313
        using namespace boost::filesystem;
916
314
917
315
        This->throw_if_not_valid(method, parent_id);
918
316
        auto sanitized_name = sanitize(method, name);
919
317
        path p = parent_id;
920
318
        p /= sanitized_name;
921
319
        // create_directory() succeeds if the directory exists already, so we need to check explicitly.
922
320
        if (exists(p))
923
321
        {
924
322
            string msg = method + ": \"" + p.native() + "\" exists already";
925
323
            throw boost::enable_current_exception(ExistsException(msg, p.native(), name));
926
324
        }
927
325
        create_directory(p);
928
326
        auto st = status(p);
929
327
        return This->make_item(method, p, st);
930
328
    };
931
329
932
330
    return invoke_async(method, do_create);
933
331
}
934
332
935
333
boost::future<unique_ptr<UploadJob>> LocalProvider::create_file(string const& parent_id,
936
334
                                                                string const& name,
937
335
                                                                int64_t size,
938
336
                                                                string const& /* content_type */,
939
337
                                                                bool allow_overwrite,
940
338
                                                                vector<string> const& /* keys */,
941
339
                                                                Context const& /* context */)
942
340
{
943
341
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
944
342
    boost::promise<unique_ptr<UploadJob>> p;
945
343
    p.set_value(make_unique<LocalUploadJob>(This, parent_id, name, size, allow_overwrite));
946
344
    return p.get_future();
947
345
}
948
346
949
347
boost::future<unique_ptr<UploadJob>> LocalProvider::update(string const& item_id,
950
348
                                                           int64_t size,
951
349
                                                           string const& old_etag,
952
350
                                                           vector<string> const& /* keys */,
953
351
                                                           Context const& /* context */)
954
352
{
955
353
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
956
354
    boost::promise<unique_ptr<UploadJob>> p;
957
355
    p.set_value(make_unique<LocalUploadJob>(This, item_id, size, old_etag));
958
356
    return p.get_future();
959
357
}
960
358
961
359
boost::future<unique_ptr<DownloadJob>> LocalProvider::download(string const& item_id,
962
360
                                                               string const& match_etag,
963
361
                                                               Context const& /* context */)
964
362
{
965
363
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
966
364
    boost::promise<unique_ptr<DownloadJob>> p;
967
365
    p.set_value(make_unique<LocalDownloadJob>(This, item_id, match_etag));
968
366
    return p.get_future();
969
367
}
970
368
971
369
boost::future<void> LocalProvider::delete_item(string const& item_id, Context const& /* context */)
972
370
{
973
371
    string const method = "delete_item()";
974
372
975
373
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
976
374
    auto do_delete = [This, method, item_id]
977
375
    {
978
376
        using namespace boost::filesystem;
979
377
980
378
        This->throw_if_not_valid(method, item_id);
981
379
        if (canonical(item_id).native() == This->root_)
982
380
        {
983
381
            string msg = method + ": cannot delete root";
984
382
            throw boost::enable_current_exception(LogicException(msg));
985
383
        }
986
384
        remove_all(item_id);
987
385
    };
988
386
989
387
    return invoke_async(method, do_delete);
990
388
}
991
389
992
390
boost::future<Item> LocalProvider::move(string const& item_id,
993
391
                                        string const& new_parent_id,
994
392
                                        string const& new_name,
995
393
                                        vector<string> const& /* keys */,
996
394
                                        Context const& /* context */)
997
395
{
998
396
    string const method = "move()";
999
397
1000
398
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
1001
399
    auto do_move = [This, method, item_id, new_parent_id, new_name]
1002
400
    {
1003
401
        using namespace boost::filesystem;
1004
402
1005
403
        This->throw_if_not_valid(method, item_id);
1006
404
        This->throw_if_not_valid(method, new_parent_id);
1007
405
        auto sanitized_name = sanitize(method, new_name);
1008
406
1009
407
        path parent_path = new_parent_id;
1010
408
        path target_path = parent_path / sanitized_name;
1011
409
1012
410
        if (exists(target_path))
1013
411
        {
1014
412
            string msg = method + ": \"" + target_path.native() + "\" exists already";
1015
413
            throw boost::enable_current_exception(ExistsException(msg, target_path.native(), new_name));
1016
414
        }
1017
415
1018
416
        // Small race condition here: if exists() just said that the target does not exist, it is
1019
417
        // possible for it to have been created since. If so, if the target is a file or an empty
1020
418
        // directory, it will be removed. In practice, this is unlikely to happen and, if it does,
1021
419
        // it is not the end of the world.
1022
420
        // TODO: deal with EXDEV
1023
421
        rename(item_id, target_path);
1024
422
        auto st = status(target_path);
1025
423
        return This->make_item(method, target_path, st);
1026
424
    };
1027
425
1028
426
    return invoke_async(method, do_move);
1029
427
}
1030
428
1031
429
boost::future<Item> LocalProvider::copy(string const& item_id,
1032
430
                                        string const& new_parent_id,
1033
431
                                        string const& new_name,
1034
432
                                        vector<string> const& /* keys */,
1035
433
                                        Context const& /* context */)
1036
434
{
1037
435
    string const method = "copy()";
1038
436
1039
437
    auto This = dynamic_pointer_cast<LocalProvider>(shared_from_this());
1040
438
    auto do_copy = [This, method, item_id, new_parent_id, new_name]
1041
439
    {
1042
440
        using namespace boost::filesystem;
1043
441
1044
442
        This->throw_if_not_valid(method, item_id);
1045
443
        This->throw_if_not_valid(method, new_parent_id);
1046
444
        auto sanitized_name = sanitize(method, new_name);
1047
445
1048
446
        path parent_path = new_parent_id;
1049
447
        path target_path = parent_path / sanitized_name;
1050
448
1051
449
        if (is_directory(item_id))
1052
450
        {
1053
451
            if (exists(target_path))
1054
452
            {
1055
453
                string msg = method + ": \"" + target_path.native() + "\" exists already";
1056
454
                throw boost::enable_current_exception(ExistsException(msg, target_path.native(), new_name));
1057
455
            }
1058
456
1059
457
            // For recursive copy, we create a temporary directory in lieu of target_path and recursively copy
1060
458
            // everything into the temporary directory. This ensures that we don't invalidate directory iterators
1061
459
            // by creating things while we are iterating, potentially getting trapped in an infinite loop.
1062
460
            path tmp_path = canonical(parent_path);
1063
461
            tmp_path /= unique_path(string(TMPFILE_PREFIX) + "-%%%%-%%%%-%%%%-%%%%");
1064
462
            create_directories(tmp_path);
1065
463
            for (directory_iterator it(item_id); it != directory_iterator(); ++it)
1066
464
            {
1067
465
                if (is_reserved_path(it->path()))
1068
466
                {
1069
467
                    continue;  // Don't recurse into the temporary directory
1070
468
                }
1071
469
                file_status s = it->status();
1072
470
                if (is_directory(s) || is_regular_file(s))
1073
471
                {
1074
472
                    path source_entry = it->path();
1075
473
                    path target_entry = tmp_path;
1076
474
                    target_entry /= source_entry.filename();
1077
475
                    copy_recursively(source_entry, target_entry);
1078
476
                }
1079
477
            }
1080
478
            rename(tmp_path, target_path);
1081
479
        }
1082
480
        else
1083
481
        {
1084
482
            copy_file(item_id, target_path);
1085
483
        }
1086
484
1087
485
        auto st = status(target_path);
1088
486
        return This->make_item(method, target_path, st);
1089
487
    };
1090
488
1091
489
    return invoke_async(method, do_copy);
1092
490
}
1093
491
1094
492
// Make sure that id does not point outside the root.
1095
493
1096
494
void LocalProvider::throw_if_not_valid(string const& method, string const& id) const
1097
495
{
1098
496
    using namespace boost::filesystem;
1099
497
1100
498
    string suspect_id;
1101
499
    try
1102
500
    {
1103
501
        suspect_id = canonical(id).native();
1104
502
    }
1105
503
    catch (filesystem_error const& e)
1106
504
    {
1107
505
        throw_storage_exception(method, e);
1108
506
    }
1109
507
1110
508
    // Disallow things such as <root>/blah/../blah even though they lead to the correct path.
1111
509
    if (suspect_id != id)
1112
510
    {
1113
511
        throw boost::enable_current_exception(InvalidArgumentException(method + ": invalid id: \"" + id + "\""));
1114
512
    }
1115
513
    // id must denote the root or have the root as a prefix.
1116
514
    auto const root_id = root_.native();
1117
515
    if (id != root_id && !boost::starts_with(id, root_id + "/"))
1118
516
    {
1119
517
        throw boost::enable_current_exception(InvalidArgumentException(method + ": invalid id: \"" + id + "\""));
1120
518
    }
1121
519
}
1122
520
1123
521
// Return an Item initialized from item_path and st.
1124
522
1125
523
Item LocalProvider::make_item(string const& method,
1126
524
                              boost::filesystem::path const& item_path,
1127
525
                              boost::filesystem::file_status const& st) const
1128
526
{
1129
527
    using namespace unity::storage;
1130
528
    using namespace unity::storage::metadata;
1131
529
    using namespace boost::filesystem;
1132
530
1133
531
    map<string, MetadataValue> meta;
1134
532
1135
533
    string const item_id = item_path.native();
1136
534
    int64_t const mtime_nsecs = get_mtime_nsecs(method, item_id);
1137
535
    string const iso_mtime = make_iso_date(mtime_nsecs);
1138
536
1139
537
    ItemType type;
1140
538
    string name = item_path.filename().native();
1141
539
    vector<string> parents{item_path.parent_path().native()};
1142
540
    string etag;
1143
541
    switch (st.type())
1144
542
    {
1145
543
        case regular_file:
1146
544
            type = ItemType::file;
1147
545
            etag = to_string(mtime_nsecs);
1148
546
            meta.insert({SIZE_IN_BYTES, int64_t(file_size(item_path))});
1149
547
            break;
1150
548
        case directory_file:
1151
549
            if (item_path == root_)
1152
550
            {
1153
551
                name = "/";
1154
552
                parents.clear();
1155
553
                type = ItemType::root;
1156
554
            }
1157
555
            else
1158
556
            {
1159
557
                type = ItemType::folder;
1160
558
            }
1161
559
            break;
1162
560
        default:
1163
561
            throw boost::enable_current_exception(
1164
562
                    NotExistsException(method + ": \"" + item_id + "\" is neither a file nor a folder", item_id));
1165
563
    }
1166
564
1167
565
1168
566
    auto const info = space(item_path);
1169
567
    meta.insert({FREE_SPACE_BYTES, int64_t(info.available)});
1170
568
    meta.insert({USED_SPACE_BYTES, int64_t(info.capacity - info.available)});
1171
569
1172
570
    meta.insert({LAST_MODIFIED_TIME, iso_mtime});
1173
571
    meta.insert({CONTENT_TYPE, get_content_type(item_id)});
1174
572
1175
573
    auto perms = st.permissions();
1176
574
    bool writable;
1177
575
    if (type == ItemType::file)
1178
576
    {
1179
577
        writable = perms & owner_write;
1180
578
    }
1181
579
    else
1182
580
    {
1183
581
        writable = perms & owner_write && perms & owner_exe;
1184
582
    }
1185
583
    meta.insert({WRITABLE, writable});
1186
584
1187
585
    return Item{ item_id, parents, name, etag, type, meta };
1188
586
}
1189
0
587
1190
=== added file 'src/local-provider/LocalProvider.h'
1191
--- src/local-provider/LocalProvider.h	1970-01-01 00:00:00 +0000
1192
+++ src/local-provider/LocalProvider.h	2017-03-17 05:04:57 +0000
1193
@@ -0,0 +1,84 @@
1194
1
/*
1195
2
 * Copyright (C) 2017 Canonical Ltd
1196
3
 *
1197
4
 * This program is free software: you can redistribute it and/or modify
1198
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1199
6
 * published by the Free Software Foundation.
1200
7
 *
1201
8
 * This program is distributed in the hope that it will be useful,
1202
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1203
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1204
11
 * GNU Lesser General Public License for more details.
1205
12
 *
1206
13
 * You should have received a copy of the GNU Lesser General Public License
1207
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1208
15
 *
1209
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1210
17
 */
1211
18
1212
19
#pragma once
1213
20
1214
21
#include <unity/storage/provider/ProviderBase.h>
1215
22
1216
23
#include <boost/filesystem.hpp>
1217
24
1218
25
class LocalProvider : public unity::storage::provider::ProviderBase
1219
26
{
1220
27
public:
1221
28
    LocalProvider();
1222
29
    virtual ~LocalProvider();
1223
30
1224
31
    boost::future<unity::storage::provider::ItemList> roots(
1225
32
        std::vector<std::string> const& metadata_keys,
1226
33
        unity::storage::provider::Context const& ctx) override;
1227
34
    boost::future<std::tuple<unity::storage::provider::ItemList, std::string>> list(
1228
35
        std::string const& item_id, std::string const& page_token,
1229
36
        std::vector<std::string> const& metadata_keys,
1230
37
        unity::storage::provider::Context const& ctx) override;
1231
38
    boost::future<unity::storage::provider::ItemList> lookup(
1232
39
        std::string const& parent_id, std::string const& name,
1233
40
        std::vector<std::string> const& metadata_keys,
1234
41
        unity::storage::provider::Context const& ctx) override;
1235
42
    boost::future<unity::storage::provider::Item> metadata(
1236
43
        std::string const& item_id,
1237
44
        std::vector<std::string> const& metadata_keys,
1238
45
        unity::storage::provider::Context const& ctx) override;
1239
46
    boost::future<unity::storage::provider::Item> create_folder(
1240
47
        std::string const& parent_id, std::string const& name,
1241
48
        std::vector<std::string> const& metadata_keys,
1242
49
        unity::storage::provider::Context const& ctx) override;
1243
50
    boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> create_file(
1244
51
        std::string const& parent_id, std::string const& name,
1245
52
        int64_t size, std::string const& content_type, bool allow_overwrite,
1246
53
        std::vector<std::string> const& metadata_keys,
1247
54
        unity::storage::provider::Context const& ctx) override;
1248
55
    boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> update(
1249
56
        std::string const& item_id, int64_t size,
1250
57
        std::string const& old_etag,
1251
58
        std::vector<std::string> const& metadata_keys,
1252
59
        unity::storage::provider::Context const& ctx) override;
1253
60
    boost::future<std::unique_ptr<unity::storage::provider::DownloadJob>> download(
1254
61
        std::string const& item_id,
1255
62
        std::string const& match_etag,
1256
63
        unity::storage::provider::Context const& ctx) override;
1257
64
    boost::future<void> delete_item(std::string const& item_id,
1258
65
        unity::storage::provider::Context const& ctx) override;
1259
66
    boost::future<unity::storage::provider::Item> move(
1260
67
        std::string const& item_id, std::string const& new_parent_id,
1261
68
        std::string const& new_name,
1262
69
        std::vector<std::string> const& metadata_keys,
1263
70
        unity::storage::provider::Context const& ctx) override;
1264
71
    boost::future<unity::storage::provider::Item> copy(
1265
72
        std::string const& item_id, std::string const& new_parent_id,
1266
73
        std::string const& new_name,
1267
74
        std::vector<std::string> const& metadata_keys,
1268
75
        unity::storage::provider::Context const& ctx) override;
1269
76
1270
77
    void throw_if_not_valid(std::string const& method, std::string const& id) const;
1271
78
    unity::storage::provider::Item make_item(std::string const& method,
1272
79
                                             boost::filesystem::path const& item_path,
1273
80
                                             boost::filesystem::file_status const& st) const;
1274
81
1275
82
private:
1276
83
    boost::filesystem::path const root_;
1277
84
};
1278
0
85
1279
=== added file 'src/local-provider/LocalUploadJob.cpp'
1280
--- src/local-provider/LocalUploadJob.cpp	1970-01-01 00:00:00 +0000
1281
+++ src/local-provider/LocalUploadJob.cpp	2017-03-17 05:04:57 +0000
1282
@@ -0,0 +1,338 @@
1283
1
/*
1284
2
 * Copyright (C) 2017 Canonical Ltd
1285
3
 *
1286
4
 * This program is free software: you can redistribute it and/or modify
1287
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1288
6
 * published by the Free Software Foundation.
1289
7
 *
1290
8
 * This program is distributed in the hope that it will be useful,
1291
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1292
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1293
11
 * GNU Lesser General Public License for more details.
1294
12
 *
1295
13
 * You should have received a copy of the GNU Lesser General Public License
1296
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1297
15
 *
1298
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1299
17
 */
1300
18
1301
19
#include "LocalUploadJob.h"
1302
20
1303
21
#include "LocalProvider.h"
1304
22
#include "utils.h"
1305
23
#include <unity/storage/internal/safe_strerror.h>
1306
24
#include <unity/storage/provider/Exceptions.h>
1307
25
#include <unity/storage/provider/ProviderBase.h>  // TODO: Should not be needed
1308
26
1309
27
#include <fcntl.h>
1310
28
1311
29
using namespace unity::storage::provider;
1312
30
using namespace std;
1313
31
1314
32
static int next_upload_id = 0;
1315
33
1316
34
LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider, int64_t size, const string& method)
1317
35
    : UploadJob(to_string(++next_upload_id))
1318
36
    , provider_(provider)
1319
37
    , size_(size)
1320
38
    , bytes_to_write_(size)
1321
39
    , method_(method)
1322
40
    , state_(in_progress)
1323
41
    , tmp_fd_([](int fd){ if (fd != -1) ::close(fd); })
1324
42
{
1325
43
}
1326
44
1327
45
LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider,
1328
46
                               string const& parent_id,
1329
47
                               string const& name,
1330
48
                               int64_t size,
1331
49
                               bool allow_overwrite)
1332
50
    : LocalUploadJob(provider, size, "create_file()")
1333
51
{
1334
52
    using namespace boost::filesystem;
1335
53
1336
54
    parent_id_ = parent_id;
1337
55
    allow_overwrite_ = allow_overwrite;
1338
56
1339
57
    provider_->throw_if_not_valid(method_, parent_id);
1340
58
1341
59
    auto sanitized_name = sanitize(method_, name);
1342
60
    path p = parent_id;
1343
61
    p /= sanitized_name;
1344
62
    item_id_ = p.native();
1345
63
    if (!allow_overwrite && exists(item_id_))
1346
64
    {
1347
65
        string msg = method_ + ": \"" + item_id_ + "\" exists already";
1348
66
        throw ExistsException(msg, item_id_, sanitized_name.native());
1349
67
    }
1350
68
1351
69
    prepare_channels();
1352
70
}
1353
71
1354
72
LocalUploadJob::LocalUploadJob(shared_ptr<LocalProvider> const& provider,
1355
73
                               string const& item_id,
1356
74
                               int64_t size,
1357
75
                               string const& old_etag)
1358
76
    : LocalUploadJob(provider, size, "update()")
1359
77
{
1360
78
    using namespace boost::filesystem;
1361
79
1362
80
    item_id_ = item_id;
1363
81
    provider_->throw_if_not_valid(method_, item_id);
1364
82
    try
1365
83
    {
1366
84
        auto st = status(item_id);
1367
85
        if (!is_regular_file(st))
1368
86
        {
1369
87
            throw InvalidArgumentException(method_ + ": \"" + item_id + "\" is not a file");
1370
88
        }
1371
89
    }
1372
90
    // LCOV_EXCL_START
1373
91
    catch (filesystem_error const& e)
1374
92
    {
1375
93
        // The call to status could throw if the file is unlinked immediately
1376
94
        // after the call to throw_if_not_valid.
1377
95
        throw_storage_exception(method_, e);
1378
96
    }
1379
97
    // LCOV_EXCL_STOP
1380
98
    if (!old_etag.empty())
1381
99
    {
1382
100
        int64_t mtime = get_mtime_nsecs(method_, item_id);
1383
101
        if (to_string(mtime) != old_etag)
1384
102
        {
1385
103
            throw ConflictException(method_ + ": etag mismatch");
1386
104
        }
1387
105
    }
1388
106
    old_etag_ = old_etag;
1389
107
1390
108
    prepare_channels();
1391
109
}
1392
110
1393
111
LocalUploadJob::~LocalUploadJob() = default;
1394
112
1395
113
void LocalUploadJob::prepare_channels()
1396
114
{
1397
115
    using namespace boost::filesystem;
1398
116
1399
117
    // Open tmp file for writing.
1400
118
    auto parent_path = path(item_id_).parent_path();
1401
119
    tmp_fd_.reset(open(parent_path.native().c_str(), O_TMPFILE | O_WRONLY, 0600));
1402
120
    if (tmp_fd_.get() == -1)
1403
121
    {
1404
122
        // Some kernels on the phones don't support O_TMPFILE and return various errno values when this fails.
1405
123
        // So, if anything at all goes wrong, we fall back on conventional temp file creation and
1406
124
        // produce a hard error if that doesn't work either.
1407
125
        // Note that, in this case, the temp file retains its name in the file system. Not nice because,
1408
126
        // if this process dies at the wrong moment, we leave the temp file behind.
1409
127
        use_linkat_ = false;
1410
128
        string tmpfile = parent_path.native() + "/" + TMPFILE_PREFIX + "-%%%%-%%%%-%%%%-%%%%";
1411
129
        tmp_fd_.reset(mkstemp(const_cast<char*>(tmpfile.data())));
1412
130
        if (tmp_fd_.get() == -1)
1413
131
        {
1414
132
            string msg = method_ + ": cannot create temp file \"" + tmpfile + "\": "
1415
133
                         + unity::storage::internal::safe_strerror(errno);
1416
134
            throw ResourceException(msg, errno);
1417
135
        }
1418
136
        // LCOV_EXCL_START
1419
137
        file_.reset(new QFile(QString::fromStdString(tmpfile)));
1420
138
        file_->open(QIODevice::WriteOnly);
1421
139
        // LCOV_EXCL_STOP
1422
140
    }
1423
141
    else
1424
142
    {
1425
143
        use_linkat_ = true;
1426
144
        file_.reset(new QFile);
1427
145
        file_->open(tmp_fd_.get(), QIODevice::WriteOnly, QFileDevice::DontCloseHandle);
1428
146
    }
1429
147
1430
148
    // Make read socket ready.
1431
149
    int dup_fd = dup(read_socket());
1432
150
    if (dup_fd == -1)
1433
151
    {
1434
152
        // LCOV_EXCL_START
1435
153
        string msg = method_ + ": dup() failed: " + unity::storage::internal::safe_strerror(errno);
1436
154
        throw ResourceException(msg, errno);
1437
155
        // LCOV_EXCL_STOP
1438
156
    }
1439
157
    read_socket_.setSocketDescriptor(dup_fd, QLocalSocket::ConnectedState, QIODevice::ReadOnly);
1440
158
    connect(&read_socket_, &QLocalSocket::readyRead, this, &LocalUploadJob::on_bytes_ready);
1441
159
    connect(&read_socket_, &QIODevice::readChannelFinished, this, &LocalUploadJob::on_read_channel_finished);
1442
160
}
1443
161
1444
162
boost::future<void> LocalUploadJob::cancel()
1445
163
{
1446
164
    if (state_ == in_progress)
1447
165
    {
1448
166
        abort_upload();
1449
167
    }
1450
168
    return boost::make_ready_future();
1451
169
}
1452
170
1453
171
boost::future<Item> LocalUploadJob::finish()
1454
172
{
1455
173
    on_bytes_ready();  // Read any remaining unread buffered data.
1456
174
1457
175
    if (bytes_to_write_ > 0)
1458
176
    {
1459
177
        string msg = "finish() method called too early, size was given as "
1460
178
                     + to_string(size_) + " but only "
1461
179
                     + to_string(size_ - bytes_to_write_) + " bytes were received";
1462
180
        return boost::make_exceptional_future<Item>(LogicException(msg));
1463
181
    }
1464
182
1465
183
    // We are committed to finishing successfully or with an error now.
1466
184
    state_ = finished;
1467
185
1468
186
    try
1469
187
    {
1470
188
        // We check again for an etag mismatch or overwrite, in case the file was updated after the upload started.
1471
189
        if (!parent_id_.empty())
1472
190
        {
1473
191
            // create_file()
1474
192
            if (!allow_overwrite_ && boost::filesystem::exists(item_id_))
1475
193
            {
1476
194
                string msg = method_ + ": \"" + item_id_ + "\" exists already";
1477
195
                boost::filesystem::path(item_id_).filename().native();
1478
196
                BOOST_THROW_EXCEPTION(
1479
197
                    ExistsException(msg, item_id_, boost::filesystem::path(item_id_).filename().native()));
1480
198
            }
1481
199
        }
1482
200
        else if (!old_etag_.empty())
1483
201
        {
1484
202
            // update()
1485
203
            int64_t mtime = get_mtime_nsecs(method_, item_id_);
1486
204
            if (to_string(mtime) != old_etag_)
1487
205
            {
1488
206
                BOOST_THROW_EXCEPTION(ConflictException(method_ + ": etag mismatch"));
1489
207
            }
1490
208
        }
1491
209
1492
210
        if (!file_->flush())  // Make sure that all buffered data is written.
1493
211
        {
1494
212
            // LCOV_EXCL_START
1495
213
            string msg = "finish(): cannot flush output file: " + file_->errorString().toStdString();
1496
214
            throw_storage_exception("finish()", msg, file_->error());
1497
215
            // LCOV_EXCL_STOP
1498
216
        }
1499
217
1500
218
        // Link the anonymous tmp file into the file system.
1501
219
        using namespace unity::storage::internal;
1502
220
1503
221
        if (use_linkat_)
1504
222
        {
1505
223
            auto old_path = string("/proc/self/fd/") + std::to_string(tmp_fd_.get());
1506
224
            ::unlink(item_id_.c_str());  // linkat() will not remove existing file: http://lwn.net/Articles/559969/
1507
225
            if (linkat(-1, old_path.c_str(), tmp_fd_.get(), item_id_.c_str(), AT_SYMLINK_FOLLOW) == -1)
1508
226
            {
1509
227
                // LCOV_EXCL_START
1510
228
                string msg = "finish(): linkat \"" + old_path + "\" to \"" + item_id_ + "\" failed: "
1511
229
                             + safe_strerror(errno);
1512
230
                BOOST_THROW_EXCEPTION(ResourceException(msg, errno));
1513
231
                // LCOV_EXCL_STOP
1514
232
            }
1515
233
        }
1516
234
        else
1517
235
        {
1518
236
            // LCOV_EXCL_START
1519
237
            auto old_path = file_->fileName().toStdString();
1520
238
            if (rename(old_path.c_str(), item_id_.c_str()) == -1)
1521
239
            {
1522
240
                string msg = "finish(): rename \"" + old_path + "\" to \"" + item_id_ + "\" failed: "
1523
241
                             + safe_strerror(errno);
1524
242
                BOOST_THROW_EXCEPTION(ResourceException(msg, errno));
1525
243
            }
1526
244
            // LCOV_EXCL_STOP
1527
245
        }
1528
246
1529
247
        file_->close();
1530
248
        read_socket_.close();
1531
249
1532
250
        auto st = boost::filesystem::status(item_id_);
1533
251
        return boost::make_ready_future<Item>(provider_->make_item(method_, item_id_, st));
1534
252
    }
1535
253
    catch (StorageException const&)
1536
254
    {
1537
255
        return boost::make_exceptional_future<Item>(boost::current_exception());
1538
256
    }
1539
257
    // LCOV_EXCL_START
1540
258
    catch (boost::filesystem::filesystem_error const& e)
1541
259
    {
1542
260
        try
1543
261
        {
1544
262
            throw_storage_exception("finish()", e);
1545
263
        }
1546
264
        catch (StorageException const&)
1547
265
        {
1548
266
            return boost::make_exceptional_future<Item>(boost::current_exception());
1549
267
        }
1550
268
    }
1551
269
    catch (std::exception const& e)
1552
270
    {
1553
271
        return boost::make_exceptional_future<Item>(UnknownException(e.what()));
1554
272
    }
1555
273
    // LCOV_EXCL_STOP
1556
274
}
1557
275
1558
276
void LocalUploadJob::on_bytes_ready()
1559
277
{
1560
278
    if (bytes_to_write_ < 0)
1561
279
    {
1562
280
        return;  // LCOV_EXCL_LINE  // We received too many bytes earlier.
1563
281
    }
1564
282
1565
283
    try
1566
284
    {
1567
285
        auto buf = read_socket_.readAll();
1568
286
        if (buf.size() != 0)
1569
287
        {
1570
288
            bytes_to_write_ -= buf.size();
1571
289
            if (bytes_to_write_ < 0)
1572
290
            {
1573
291
                string msg = method_ + ": received more than the expected number (" + to_string(size_) + ") of bytes";
1574
292
                throw LogicException(msg);
1575
293
            }
1576
294
            auto bytes_written = file_->write(buf);
1577
295
            if (bytes_written == -1)
1578
296
            {
1579
297
                // LCOV_EXCL_START
1580
298
                string msg = "write error: " + file_->errorString().toStdString();
1581
299
                throw_storage_exception(method_, msg, file_->error());
1582
300
                // LCOV_EXCL_STOP
1583
301
            }
1584
302
            else if (bytes_written != buf.size())
1585
303
            {
1586
304
                // LCOV_EXCL_START
1587
305
                string msg = "write error, requested " + to_string(buf.size()) + " B, but wrote only "
1588
306
                             + to_string(bytes_written) + " B.";
1589
307
                throw_storage_exception(method_, msg, QFileDevice::FatalError);
1590
308
                // LCOV_EXCL_STOP
1591
309
            }
1592
310
        }
1593
311
    }
1594
312
    catch (std::exception const&)
1595
313
    {
1596
314
        abort_upload();
1597
315
        report_error(current_exception());
1598
316
    }
1599
317
}
1600
318
1601
319
void LocalUploadJob::on_read_channel_finished()
1602
320
{
1603
321
    on_bytes_ready();  // In case there s still buffered data to be read.
1604
322
}
1605
323
1606
324
void LocalUploadJob::abort_upload()
1607
325
{
1608
326
    state_ = cancelled;
1609
327
    disconnect(&read_socket_, nullptr, this, nullptr);
1610
328
    read_socket_.abort();
1611
329
    file_->close();
1612
330
    if (!use_linkat_)
1613
331
    {
1614
332
        // LCOV_EXCL_START
1615
333
        string filename = file_->fileName().toStdString();
1616
334
        ::unlink(filename.c_str());  // Don't leave any temp file behind.
1617
335
        // LCOV_EXCL_STOP
1618
336
    }
1619
337
    bytes_to_write_ = 0;
1620
338
}
1621
0
339
1622
=== added file 'src/local-provider/LocalUploadJob.h'
1623
--- src/local-provider/LocalUploadJob.h	1970-01-01 00:00:00 +0000
1624
+++ src/local-provider/LocalUploadJob.h	2017-03-17 05:04:57 +0000
1625
@@ -0,0 +1,79 @@
1626
1
/*
1627
2
 * Copyright (C) 2017 Canonical Ltd
1628
3
 *
1629
4
 * This program is free software: you can redistribute it and/or modify
1630
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1631
6
 * published by the Free Software Foundation.
1632
7
 *
1633
8
 * This program is distributed in the hope that it will be useful,
1634
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1635
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1636
11
 * GNU Lesser General Public License for more details.
1637
12
 *
1638
13
 * You should have received a copy of the GNU Lesser General Public License
1639
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1640
15
 *
1641
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1642
17
 */
1643
18
1644
19
#pragma once
1645
20
1646
21
#include <unity/storage/provider/UploadJob.h>
1647
22
1648
23
#include <unity/util/ResourcePtr.h>
1649
24
1650
25
#pragma GCC diagnostic push
1651
26
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1652
27
#pragma GCC diagnostic ignored "-Wswitch-default"
1653
28
#include <QFile>
1654
29
#include <QLocalSocket>
1655
30
#pragma GCC diagnostic pop
1656
31
1657
32
class LocalProvider;
1658
33
1659
34
class LocalUploadJob : public QObject, public unity::storage::provider::UploadJob
1660
35
{
1661
36
    Q_OBJECT
1662
37
public:
1663
38
    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider, int64_t size, const std::string& method);
1664
39
1665
40
    // create_file()
1666
41
    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider,
1667
42
                   std::string const& parent_id,
1668
43
                   std::string const& name,
1669
44
                   int64_t size,
1670
45
                   bool allow_overwrite);
1671
46
    // update()
1672
47
    LocalUploadJob(std::shared_ptr<LocalProvider> const& provider,
1673
48
                   std::string const& item_id,
1674
49
                   int64_t size,
1675
50
                   std::string const& old_etag);
1676
51
    virtual ~LocalUploadJob();
1677
52
1678
53
    virtual boost::future<void> cancel() override;
1679
54
    virtual boost::future<unity::storage::provider::Item> finish() override;
1680
55
1681
56
private Q_SLOTS:
1682
57
    void on_bytes_ready();
1683
58
    void on_read_channel_finished();
1684
59
1685
60
private:
1686
61
    enum State { in_progress, finished, cancelled };
1687
62
1688
63
    void prepare_channels();
1689
64
    void abort_upload();
1690
65
1691
66
    std::shared_ptr<LocalProvider> const provider_;
1692
67
    int64_t const size_;
1693
68
    int64_t bytes_to_write_;
1694
69
    std::unique_ptr<QFile> file_;
1695
70
    QLocalSocket read_socket_;
1696
71
    std::string const method_;
1697
72
    State state_;
1698
73
    std::string item_id_;
1699
74
    std::string old_etag_;   // Empty for create_file()
1700
75
    std::string parent_id_;  // Empty for update()
1701
76
    bool allow_overwrite_;   // Undefined for update()
1702
77
    unity::util::ResourcePtr<int, std::function<void(int)>> tmp_fd_;
1703
78
    bool use_linkat_;
1704
79
};
1705
0
80
1706
=== added file 'src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in'
1707
--- src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in	1970-01-01 00:00:00 +0000
1708
+++ src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in	2017-03-17 05:04:57 +0000
1709
@@ -0,0 +1,3 @@
1710
1
[D-BUS Service]
1711
2
Name=com.canonical.StorageFramework.Provider.Local
1712
3
Exec=@CMAKE_INSTALL_FULL_LIBDIR@/@PROJECT_NAME@/storage-provider-local
1713
0
4
1714
=== added file 'src/local-provider/main.cpp'
1715
--- src/local-provider/main.cpp	1970-01-01 00:00:00 +0000
1716
+++ src/local-provider/main.cpp	2017-03-17 05:04:57 +0000
1717
@@ -0,0 +1,52 @@
1718
1
/*
1719
2
 * Copyright (C) 2017 Canonical Ltd
1720
3
 *
1721
4
 * This program is free software: you can redistribute it and/or modify
1722
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1723
6
 * published by the Free Software Foundation.
1724
7
 *
1725
8
 * This program is distributed in the hope that it will be useful,
1726
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1727
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1728
11
 * GNU Lesser General Public License for more details.
1729
12
 *
1730
13
 * You should have received a copy of the GNU Lesser General Public License
1731
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1732
15
 *
1733
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1734
17
 */
1735
18
1736
19
#include <unity/storage/provider/Server.h>
1737
20
1738
21
#include "LocalProvider.h"
1739
22
1740
23
#include <boost/filesystem.hpp>
1741
24
1742
25
#include <iostream>
1743
26
1744
27
using namespace std;
1745
28
using namespace unity::storage::provider;
1746
29
1747
30
int main(int argc, char* argv[])
1748
31
{
1749
32
    using namespace boost::filesystem;
1750
33
1751
34
    string const bus_name = "com.canonical.StorageFramework.Provider.Local";
1752
35
    string const account_service_id = "";
1753
36
1754
37
    string progname = argv[0];
1755
38
1756
39
    try
1757
40
    {
1758
41
        progname = path(progname).filename().native();
1759
42
1760
43
        Server<LocalProvider> server(bus_name, account_service_id);
1761
44
        server.init(argc, argv);
1762
45
        server.run();
1763
46
    }
1764
47
    catch (std::exception const& e)
1765
48
    {
1766
49
        cerr << progname << ": " << e.what() << endl;
1767
50
        return 1;
1768
51
    }
1769
52
}
1770
0
53
1771
=== added file 'src/local-provider/utils.cpp'
1772
--- src/local-provider/utils.cpp	1970-01-01 00:00:00 +0000
1773
+++ src/local-provider/utils.cpp	2017-03-17 05:04:57 +0000
1774
@@ -0,0 +1,146 @@
1775
1
/*
1776
2
 * Copyright (C) 2017 Canonical Ltd
1777
3
 *
1778
4
 * This program is free software: you can redistribute it and/or modify
1779
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1780
6
 * published by the Free Software Foundation.
1781
7
 *
1782
8
 * This program is distributed in the hope that it will be useful,
1783
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1784
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1785
11
 * GNU Lesser General Public License for more details.
1786
12
 *
1787
13
 * You should have received a copy of the GNU Lesser General Public License
1788
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1789
15
 *
1790
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1791
17
 */
1792
18
1793
19
#include "utils.h"
1794
20
1795
21
#include <unity/storage/internal/safe_strerror.h>
1796
22
#include <unity/storage/provider/Exceptions.h>
1797
23
1798
24
#include <boost/algorithm/string.hpp>
1799
25
#include <boost/exception/enable_current_exception.hpp>
1800
26
1801
27
#include <sys/stat.h>
1802
28
1803
29
using namespace unity::storage::provider;
1804
30
using namespace std;
1805
31
1806
32
// Return modification time in nanoseconds since the epoch.
1807
33
1808
34
int64_t get_mtime_nsecs(string const& method, string const& path)
1809
35
{
1810
36
    using namespace unity::storage::internal;
1811
37
1812
38
    struct stat st;
1813
39
    if (stat(path.c_str(), &st) == -1)
1814
40
    {
1815
41
        // LCOV_EXCL_START
1816
42
        string msg = method + ": cannot stat \"" + path + "\": " + safe_strerror(errno);
1817
43
        throw boost::enable_current_exception(ResourceException(msg, errno));
1818
44
        // LCOV_EXCL_STOP
1819
45
    }
1820
46
    return int64_t(st.st_mtim.tv_sec) * 1000000000 + st.st_mtim.tv_nsec;
1821
47
}
1822
48
1823
49
// Return true if the path uses the temp file prefix.
1824
50
1825
51
bool is_reserved_path(boost::filesystem::path const& path)
1826
52
{
1827
53
    string filename = path.filename().native();
1828
54
    return boost::starts_with(filename, TMPFILE_PREFIX);
1829
55
}
1830
56
1831
57
// Check that name is a valid file or directory name, that is, has a single component
1832
58
// and is not "", ".", or "..". Also check that the name does not start with the
1833
59
// temp file prefix. Throw if the name is invalid.
1834
60
1835
61
boost::filesystem::path sanitize(string const& method, string const& name)
1836
62
{
1837
63
    using namespace boost::filesystem;
1838
64
1839
65
    path p = name;
1840
66
    if (!p.parent_path().empty())
1841
67
    {
1842
68
        // name contains more than one component.
1843
69
        string msg = method + ": name \"" + name + "\" cannot contain a slash";
1844
70
        throw boost::enable_current_exception(InvalidArgumentException(msg));
1845
71
    }
1846
72
    path filename = p.filename();
1847
73
    if (filename.empty() || filename == "." || filename == "..")
1848
74
    {
1849
75
        // Not an allowable file name.
1850
76
        string msg = method + ": invalid name: \"" + name + "\"";
1851
77
        throw boost::enable_current_exception(InvalidArgumentException(msg));
1852
78
    }
1853
79
    if (is_reserved_path(filename))
1854
80
    {
1855
81
        string msg = string(method + ": names beginning with \"") + TMPFILE_PREFIX + "\" are reserved";
1856
82
        throw boost::enable_current_exception(InvalidArgumentException(msg));
1857
83
    }
1858
84
    return p;
1859
85
}
1860
86
1861
87
// Throw a StorageException that corresponds to a boost::filesystem_error.
1862
88
1863
89
void throw_storage_exception(string const& method, boost::filesystem::filesystem_error const& e)
1864
90
{
1865
91
    using namespace boost::system::errc;
1866
92
1867
93
    string msg = method + ": ";
1868
94
    string path1 = e.path1().native();
1869
95
    string path2 = e.path2().native();
1870
96
    if (!path2.empty())
1871
97
    {
1872
98
        msg += "src = \"" + path1 + "\", target = \"" + path2 + "\"";  // LCOV_EXCL_LINE
1873
99
    }
1874
100
    else
1875
101
    {
1876
102
        msg += "\"" + path1 + "\"";
1877
103
    }
1878
104
    msg += string(": ") + e.what();
1879
105
    switch (e.code().value())
1880
106
    {
1881
107
        case permission_denied:
1882
108
        case operation_not_permitted:
1883
109
            throw boost::enable_current_exception(PermissionException(msg));
1884
110
        case no_such_file_or_directory:
1885
111
            throw boost::enable_current_exception(NotExistsException(msg, e.path1().native()));
1886
112
        // LCOV_EXCL_START
1887
113
        case file_exists:
1888
114
            throw boost::enable_current_exception(
1889
115
                    ExistsException(msg, e.path1().native(), e.path1().filename().native()));
1890
116
        case no_space_on_device:
1891
117
            throw boost::enable_current_exception(QuotaException(msg));
1892
118
        default:
1893
119
            throw boost::enable_current_exception(ResourceException(msg, e.code().value()));
1894
120
        // LCOV_EXCL_STOP
1895
121
    }
1896
122
}
1897
123
1898
124
// Throw a storage exception that corresponds to a FileError.
1899
125
1900
126
void throw_storage_exception(string const& method, string const& msg, QFileDevice::FileError e)
1901
127
{
1902
128
    string const error_msg = method + ": " + msg;
1903
129
    switch (e)
1904
130
    {
1905
131
        case QFileDevice::NoError:
1906
132
            abort();  // LCOV_EXCL_LINE  // Precondition violation
1907
133
            break;
1908
134
        default:
1909
135
            throw ResourceException(error_msg + " (QFileDevice::FileError = " + to_string(e) + ")", e);
1910
136
    }
1911
137
}
1912
138
1913
139
// Throw a storage exception that corresponds to a LocalSocketError.
1914
140
1915
141
// LCOV_EXCL_START
1916
142
void throw_storage_exception(string const& method, string const& msg, QLocalSocket::LocalSocketError e)
1917
143
{
1918
144
    throw ResourceException(method + ": " + msg + " (QLocalSocket::LocalSocketError = " + to_string(e) + ")", e);
1919
145
}
1920
146
// LCOV_EXCL_STOP
1921
0
147
1922
=== added file 'src/local-provider/utils.h'
1923
--- src/local-provider/utils.h	1970-01-01 00:00:00 +0000
1924
+++ src/local-provider/utils.h	2017-03-17 05:04:57 +0000
1925
@@ -0,0 +1,45 @@
1926
1
/*
1927
2
 * Copyright (C) 2017 Canonical Ltd
1928
3
 *
1929
4
 * This program is free software: you can redistribute it and/or modify
1930
5
 * it under the terms of the GNU Lesser General Public License version 3 as
1931
6
 * published by the Free Software Foundation.
1932
7
 *
1933
8
 * This program is distributed in the hope that it will be useful,
1934
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1935
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1936
11
 * GNU Lesser General Public License for more details.
1937
12
 *
1938
13
 * You should have received a copy of the GNU Lesser General Public License
1939
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1940
15
 *
1941
16
 * Authors: Michi Henning <michi.henning@canonical.com>
1942
17
 */
1943
18
1944
19
#pragma once
1945
20
1946
21
#include <boost/filesystem.hpp>
1947
22
1948
23
#pragma GCC diagnostic push
1949
24
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1950
25
#include <QFileDevice>
1951
26
#include <QLocalSocket>
1952
27
#include <QString>
1953
28
#pragma GCC diagnostic pop
1954
29
1955
30
#include <string>
1956
31
1957
32
constexpr char const* TMPFILE_PREFIX = ".storage-framework";
1958
33
1959
34
int64_t get_mtime_nsecs(std::string const& method, std::string const& path);
1960
35
bool is_reserved_path(boost::filesystem::path const& path);
1961
36
boost::filesystem::path sanitize(std::string const& method, std::string const& name);
1962
37
1963
38
[[ noreturn ]]
1964
39
void throw_storage_exception(std::string const& method, boost::filesystem::filesystem_error const& e);
1965
40
1966
41
[[ noreturn ]]
1967
42
void throw_storage_exception(std::string const& method, std::string const& msg, QFileDevice::FileError e);
1968
43
1969
44
[[ noreturn ]]
1970
45
void throw_storage_exception(std::string const& method, std::string const& msg, QLocalSocket::LocalSocketError e);
1971
0
46
1972
=== modified file 'src/qt/internal/RuntimeImpl.cpp'
1973
--- src/qt/internal/RuntimeImpl.cpp	2016-11-21 13:29:39 +0000
1974
+++ src/qt/internal/RuntimeImpl.cpp	2017-03-17 05:04:57 +0000
1975
@@ -24,9 +24,11 @@
1976
24
#include <unity/storage/qt/internal/AccountImpl.h>
24
#include <unity/storage/qt/internal/AccountImpl.h>
1977
25
#include <unity/storage/qt/internal/AccountsJobImpl.h>
25
#include <unity/storage/qt/internal/AccountsJobImpl.h>
1978
26
#include <unity/storage/qt/internal/StorageErrorImpl.h>
26
#include <unity/storage/qt/internal/StorageErrorImpl.h>
1979
27
#include <unity/storage/qt/Downloader.h>
1980
27
#include <unity/storage/qt/ItemJob.h>
28
#include <unity/storage/qt/ItemJob.h>
1981
28
#include <unity/storage/qt/ItemListJob.h>
29
#include <unity/storage/qt/ItemListJob.h>
1982
29
#include <unity/storage/qt/Runtime.h>
30
#include <unity/storage/qt/Runtime.h>
1983
31
#include <unity/storage/qt/Uploader.h>
1984
30
#include <unity/storage/qt/VoidJob.h>
32
#include <unity/storage/qt/VoidJob.h>
1985
31
#include <unity/storage/registry/Registry.h>
33
#include <unity/storage/registry/Registry.h>
1986
32
34
1987
@@ -51,10 +53,12 @@
1988
51
    qRegisterMetaType<unity::storage::qt::AccountsJob::Status>();
53
    qRegisterMetaType<unity::storage::qt::AccountsJob::Status>();
1989
52
    qRegisterMetaType<unity::storage::qt::Account>();
54
    qRegisterMetaType<unity::storage::qt::Account>();
1990
53
    qRegisterMetaType<QList<unity::storage::qt::Account>>();
55
    qRegisterMetaType<QList<unity::storage::qt::Account>>();
1991
56
    qRegisterMetaType<unity::storage::qt::Downloader::Status>();
1992
54
    qRegisterMetaType<unity::storage::qt::Item>();
57
    qRegisterMetaType<unity::storage::qt::Item>();
1993
55
    qRegisterMetaType<QList<unity::storage::qt::Item>>();
58
    qRegisterMetaType<QList<unity::storage::qt::Item>>();
1994
56
    qRegisterMetaType<unity::storage::qt::ItemJob::Status>();
59
    qRegisterMetaType<unity::storage::qt::ItemJob::Status>();
1995
57
    qRegisterMetaType<unity::storage::qt::ItemListJob::Status>();
60
    qRegisterMetaType<unity::storage::qt::ItemListJob::Status>();
1996
61
    qRegisterMetaType<unity::storage::qt::Uploader::Status>();
1997
58
    qRegisterMetaType<unity::storage::qt::VoidJob::Status>();
62
    qRegisterMetaType<unity::storage::qt::VoidJob::Status>();
1998
59
63
1999
60
    qDBusRegisterMetaType<unity::storage::internal::ItemMetadata>();
64
    qDBusRegisterMetaType<unity::storage::internal::ItemMetadata>();
2000
61
65
2001
=== modified file 'src/qt/internal/StorageErrorImpl.cpp'
2002
--- src/qt/internal/StorageErrorImpl.cpp	2017-01-24 06:12:09 +0000
2003
+++ src/qt/internal/StorageErrorImpl.cpp	2017-03-17 05:04:57 +0000
2004
@@ -78,7 +78,6 @@
2005
78
           || type == StorageError::Type::Cancelled
78
           || type == StorageError::Type::Cancelled
2006
79
           || type == StorageError::Type::LogicError
79
           || type == StorageError::Type::LogicError
2007
80
           || type == StorageError::Type::InvalidArgument);
80
           || type == StorageError::Type::InvalidArgument);
2008
81
    assert(!msg.isEmpty());
2009
82
81
2010
83
    message_ = msg;
82
    message_ = msg;
2011
84
}
83
}
2012
@@ -87,7 +86,6 @@
2013
87
    : StorageErrorImpl(type)
86
    : StorageErrorImpl(type)
2014
88
{
87
{
2015
89
    assert(type == StorageError::Type::NotExists);
88
    assert(type == StorageError::Type::NotExists);
2016
90
    assert(!msg.isEmpty());
2017
91
89
2018
92
    message_ = msg;
90
    message_ = msg;
2019
93
    item_id_ = key;
91
    item_id_ = key;
2020
@@ -104,9 +102,6 @@
2021
104
    : StorageErrorImpl(type)
102
    : StorageErrorImpl(type)
2022
105
{
103
{
2023
106
    assert(type == StorageError::Type::Exists);
104
    assert(type == StorageError::Type::Exists);
2024
107
    assert(!msg.isEmpty());
2025
108
    assert(!item_id.isEmpty());
2026
109
    assert(!item_name.isEmpty());
2027
110
105
2028
111
    message_ = msg;
106
    message_ = msg;
2029
112
    item_id_ = item_id;
107
    item_id_ = item_id;
2030
@@ -117,7 +112,6 @@
2031
117
    : StorageErrorImpl(type)
112
    : StorageErrorImpl(type)
2032
118
{
113
{
2033
119
    assert(type == StorageError::Type::ResourceError);
114
    assert(type == StorageError::Type::ResourceError);
2034
120
    assert(!msg.isEmpty());
2035
121
115
2036
122
    message_ = msg;
116
    message_ = msg;
2037
123
    error_code_ = error_code;
117
    error_code_ = error_code;
2038
124
118
2039
=== modified file 'tests/CMakeLists.txt'
2040
--- tests/CMakeLists.txt	2017-03-07 10:23:24 +0000
2041
+++ tests/CMakeLists.txt	2017-03-17 05:04:57 +0000
2042
@@ -8,6 +8,7 @@
2043
8
set(unit_test_dirs
8
set(unit_test_dirs
2044
9
    registry
9
    registry
2045
10
    local-client
10
    local-client
2046
11
    local-provider
2047
11
    remote-client
12
    remote-client
2048
12
    remote-client-v1
13
    remote-client-v1
2049
13
    provider-AccountData
14
    provider-AccountData
2050
14
15
2051
=== added directory 'tests/local-provider'
2052
=== added file 'tests/local-provider/CMakeLists.txt'
2053
--- tests/local-provider/CMakeLists.txt	1970-01-01 00:00:00 +0000
2054
+++ tests/local-provider/CMakeLists.txt	2017-03-17 05:04:57 +0000
2055
@@ -0,0 +1,18 @@
2056
1
add_executable(local-provider_test local-provider_test.cpp)
2057
2
2058
3
add_definitions(-DTEST_DIR="${CMAKE_CURRENT_BINARY_DIR}" -DBOOST_THREAD_VERSION=4)
2059
4
2060
5
target_link_libraries(local-provider_test
2061
6
    local-provider-lib
2062
7
    storage-framework-provider
2063
8
    storage-framework-qt-client-v2
2064
9
    Qt5::Test
2065
10
    ${Boost_LIBRARIES}
2066
11
    ${GLIB_DEPS_LIBRARIES}
2067
12
    ${GIO_DEPS_LIBRARIES}
2068
13
    testutils
2069
14
    gtest
2070
15
)
2071
16
add_test(local-provider local-provider_test)
2072
17
2073
18
set(UNIT_TEST_TARGETS ${UNIT_TEST_TARGETS} PARENT_SCOPE)
2074
0
19
2075
=== added file 'tests/local-provider/local-provider_test.cpp'
2076
--- tests/local-provider/local-provider_test.cpp	1970-01-01 00:00:00 +0000
2077
+++ tests/local-provider/local-provider_test.cpp	2017-03-17 05:04:57 +0000
2078
@@ -0,0 +1,1473 @@
2079
1
/*
2080
2
 * Copyright (C) 2017 Canonical Ltd
2081
3
 *
2082
4
 * This program is free software: you can redistribute it and/or modify
2083
5
 * it under the terms of the GNU Lesser General Public License version 3 as
2084
6
 * published by the Free Software Foundation.
2085
7
 *
2086
8
 * This program is distributed in the hope that it will be useful,
2087
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2088
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2089
11
 * GNU Lesser General Public License for more details.
2090
12
 *
2091
13
 * You should have received a copy of the GNU Lesser General Public License
2092
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2093
15
 *
2094
16
 * Authors: Michi Henning <michi.henning@canonical.com>
2095
17
 */
2096
18
2097
19
#include "../../src/local-provider/LocalDownloadJob.h"
2098
20
#include "../../src/local-provider/LocalProvider.h"
2099
21
#include "../../src/local-provider/LocalUploadJob.h"
2100
22
2101
23
#include <unity/storage/provider/DownloadJob.h>
2102
24
#include <unity/storage/provider/Exceptions.h>
2103
25
#include <unity/storage/provider/Server.h>
2104
26
#include <unity/storage/qt/client-api.h>
2105
27
#include <utils/env_var_guard.h>
2106
28
#include <utils/ProviderFixture.h>
2107
29
2108
30
#include <boost/algorithm/string.hpp>
2109
31
#include <gtest/gtest.h>
2110
32
#include <QCoreApplication>
2111
33
#include <QSignalSpy>
2112
34
2113
35
#include <chrono>
2114
36
#include <regex>
2115
37
2116
38
#include <fcntl.h>
2117
39
2118
40
using namespace unity::storage;
2119
41
using namespace std;
2120
42
2121
43
namespace
2122
44
{
2123
45
2124
46
int64_t nanosecs_now()
2125
47
{
2126
48
    return chrono::system_clock::now().time_since_epoch() / chrono::nanoseconds(1);
2127
49
}
2128
50
2129
51
string const ROOT_DIR = TEST_DIR "/data";
2130
52
2131
53
class LocalProviderTest : public ProviderFixture
2132
54
{
2133
55
protected:
2134
56
    void SetUp() override
2135
57
    {
2136
58
        boost::filesystem::remove_all(ROOT_DIR);
2137
59
        boost::filesystem::create_directory(ROOT_DIR);
2138
60
2139
61
        ProviderFixture::SetUp();
2140
62
        runtime_.reset(new qt::Runtime(connection()));
2141
63
        acc_ = runtime_->make_test_account(service_connection_->baseService(), object_path());
2142
64
    }
2143
65
2144
66
    void TearDown() override
2145
67
    {
2146
68
        runtime_.reset();
2147
69
        ProviderFixture::TearDown();
2148
70
    }
2149
71
2150
72
    unique_ptr<qt::Runtime> runtime_;
2151
73
    qt::Account acc_;
2152
74
};
2153
75
2154
76
constexpr int SIGNAL_WAIT_TIME = 30000;
2155
77
2156
78
template <typename Job>
2157
79
void wait(Job* job)
2158
80
{
2159
81
    QSignalSpy spy(job, &Job::statusChanged);
2160
82
    while (job->status() == Job::Loading)
2161
83
    {
2162
84
        if (!spy.wait(SIGNAL_WAIT_TIME))
2163
85
        {
2164
86
            throw runtime_error("Wait for statusChanged signal timed out");
2165
87
        }
2166
88
    }
2167
89
}
2168
90
2169
91
qt::Item get_root(qt::Account const& account)
2170
92
{
2171
93
    unique_ptr<qt::ItemListJob> j(account.roots());
2172
94
    assert(j->isValid());
2173
95
    QSignalSpy ready_spy(j.get(), &qt::ItemListJob::itemsReady);
2174
96
    assert(ready_spy.wait(SIGNAL_WAIT_TIME));
2175
97
    auto arg = ready_spy.takeFirst();
2176
98
    auto items = qvariant_cast<QList<qt::Item>>(arg.at(0));
2177
99
    assert(items.size() == 1);
2178
100
    return items[0];
2179
101
}
2180
102
2181
103
QList<qt::Item> get_items(qt::ItemListJob *job)
2182
104
{
2183
105
    QList<qt::Item> items;
2184
106
    auto connection = QObject::connect(
2185
107
        job, &qt::ItemListJob::itemsReady,
2186
108
        [&](QList<qt::Item> const& new_items)
2187
109
        {
2188
110
            items.append(new_items);
2189
111
        });
2190
112
    try
2191
113
    {
2192
114
        wait(job);
2193
115
    }
2194
116
    catch (...)
2195
117
    {
2196
118
        QObject::disconnect(connection);
2197
119
        throw;
2198
120
    }
2199
121
    QObject::disconnect(connection);
2200
122
    return items;
2201
123
}
2202
124
2203
125
const string file_contents =
2204
126
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
2205
127
    "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut "
2206
128
    "enim ad minim veniam, quis nostrud exercitation ullamco laboris "
2207
129
    "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor "
2208
130
    "in reprehenderit in voluptate velit esse cillum dolore eu fugiat "
2209
131
    "nulla pariatur. Excepteur sint occaecat cupidatat non proident, "
2210
132
    "sunt in culpa qui officia deserunt mollit anim id est laborum.\n";
2211
133
2212
134
}  // namespace
2213
135
2214
136
TEST(Directories, env_vars)
2215
137
{
2216
138
    // These tests cause the constructor to throw, so we instantiate the provider directly.
2217
139
2218
140
    {
2219
141
        EnvVarGuard env("SF_LOCAL_PROVIDER_ROOT", "/no_such_dir");
2220
142
2221
143
        try
2222
144
        {
2223
145
            LocalProvider();
2224
146
            FAIL();
2225
147
        }
2226
148
        catch (provider::InvalidArgumentException const& e)
2227
149
        {
2228
150
            EXPECT_STREQ("InvalidArgumentException: LocalProvider(): Environment variable "
2229
151
                         "SF_LOCAL_PROVIDER_ROOT must denote an existing directory",
2230
152
                         e.what());
2231
153
        }
2232
154
    }
2233
155
2234
156
    {
2235
157
        EnvVarGuard env("SF_LOCAL_PROVIDER_ROOT", TEST_DIR "/Makefile");
2236
158
2237
159
        try
2238
160
        {
2239
161
            LocalProvider();
2240
162
            FAIL();
2241
163
        }
2242
164
        catch (provider::InvalidArgumentException const& e)
2243
165
        {
2244
166
            EXPECT_STREQ("InvalidArgumentException: LocalProvider(): Environment variable "
2245
167
                         "SF_LOCAL_PROVIDER_ROOT must denote an existing directory",
2246
168
                         e.what());
2247
169
        }
2248
170
    }
2249
171
2250
172
    {
2251
173
        string const dir = TEST_DIR "/noperm";
2252
174
2253
175
        mkdir(dir.c_str(), 0555);
2254
176
        ASSERT_EQ(0, chmod(dir.c_str(), 0555));  // In case dir was there already.
2255
177
2256
178
        EnvVarGuard env1("SF_LOCAL_PROVIDER_ROOT", nullptr);
2257
179
        EnvVarGuard env2("XDG_DATA_HOME", dir.c_str());
2258
180
2259
181
        using namespace boost::filesystem;
2260
182
2261
183
        try
2262
184
        {
2263
185
            LocalProvider();
2264
186
            ASSERT_EQ(0, chmod(dir.c_str(), 0775));
2265
187
            remove_all(dir);
2266
188
            FAIL();
2267
189
        }
2268
190
        catch (provider::PermissionException const& e)
2269
191
        {
2270
192
            EXPECT_EQ(string("PermissionException: LocalProvider(): \"") + dir + "/storage-framework\": "
2271
193
                      "boost::filesystem::create_directories: Permission denied: \"" + dir + "/storage-framework\"",
2272
194
                      e.what());
2273
195
        }
2274
196
2275
197
        ASSERT_EQ(0, chmod(dir.c_str(), 0775));
2276
198
        ASSERT_TRUE(remove_all(dir));
2277
199
2278
200
        // Try again, which must succeed now (for coverage).
2279
201
        LocalProvider();
2280
202
        ASSERT_TRUE(is_directory(dir + "/storage-framework/local"));
2281
203
        ASSERT_TRUE(remove_all(dir));
2282
204
    }
2283
205
2284
206
    {
2285
207
        string const dir = TEST_DIR "/snap_user_common";
2286
208
        mkdir(dir.c_str(), 0775);
2287
209
2288
210
        EnvVarGuard env1("SF_LOCAL_PROVIDER_ROOT", nullptr);
2289
211
        EnvVarGuard env2("SNAP_USER_COMMON", dir.c_str());
2290
212
2291
213
        using namespace boost::filesystem;
2292
214
2293
215
        LocalProvider();
2294
216
        ASSERT_TRUE(exists(dir + "/storage-framework/local"));
2295
217
        ASSERT_TRUE(remove_all(dir));
2296
218
    }
2297
219
}
2298
220
2299
221
TEST_F(LocalProviderTest, basic)
2300
222
{
2301
223
    using namespace unity::storage::qt;
2302
224
2303
225
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2304
226
2305
227
    // Basic sanity check, get the root.
2306
228
    unique_ptr<ItemListJob> j(acc_.roots());
2307
229
    EXPECT_TRUE(j->isValid());
2308
230
    QSignalSpy ready_spy(j.get(), &ItemListJob::itemsReady);
2309
231
    ASSERT_TRUE(ready_spy.wait(SIGNAL_WAIT_TIME));
2310
232
    ASSERT_EQ(1, ready_spy.count());
2311
233
    auto arg = ready_spy.takeFirst();
2312
234
    auto items = qvariant_cast<QList<Item>>(arg.at(0));
2313
235
    ASSERT_EQ(1, items.size());
2314
236
2315
237
    // Check contents of returned item.
2316
238
    auto root = items[0];
2317
239
    EXPECT_TRUE(root.isValid());
2318
240
    EXPECT_EQ(Item::Type::Root, root.type());
2319
241
    EXPECT_EQ(ROOT_DIR, root.itemId().toStdString());
2320
242
    EXPECT_EQ("/", root.name());
2321
243
    EXPECT_EQ("", root.etag());
2322
244
    EXPECT_EQ(QList<QString>(), root.parentIds());
2323
245
    qDebug() << root.lastModifiedTime();
2324
246
    EXPECT_TRUE(root.lastModifiedTime().isValid());
2325
247
    EXPECT_EQ(acc_, root.account());
2326
248
2327
249
    ASSERT_EQ(5, root.metadata().size());
2328
250
    auto free_space_bytes = root.metadata().value("free_space_bytes").toULongLong();
2329
251
    cout << "free_space_bytes: " << free_space_bytes << endl;
2330
252
    EXPECT_GT(free_space_bytes, 0);
2331
253
    auto used_space_bytes = root.metadata().value("used_space_bytes").toULongLong();
2332
254
    cout << "used_space_bytes: " << used_space_bytes << endl;
2333
255
    EXPECT_GT(used_space_bytes, 0);
2334
256
    auto content_type = root.metadata().value("content_type").toString();
2335
257
    EXPECT_EQ("inode/directory", content_type);
2336
258
    auto writable = root.metadata().value("writable").toBool();
2337
259
    EXPECT_TRUE(writable);
2338
260
2339
261
    // yyyy-mm-ddThh:mm:ssZ
2340
262
    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$";
2341
263
    string mtime = root.metadata().value("last_modified_time").toString().toStdString();
2342
264
    cout << "last_modified_time: " << mtime << endl;
2343
265
    regex re(date_time_fmt);
2344
266
    EXPECT_TRUE(regex_match(mtime, re));
2345
267
}
2346
268
2347
269
TEST_F(LocalProviderTest, create_folder)
2348
270
{
2349
271
    {
2350
272
        using namespace unity::storage::qt;
2351
273
2352
274
        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2353
275
2354
276
        auto root = get_root(acc_);
2355
277
        unique_ptr<ItemJob> job(root.createFolder("child"));
2356
278
        wait(job.get());
2357
279
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2358
280
2359
281
        Item child = job->item();
2360
282
        EXPECT_EQ(ROOT_DIR + "/child", child.itemId().toStdString());
2361
283
        EXPECT_EQ("child", child.name().toStdString());
2362
284
        ASSERT_EQ(1, child.parentIds().size());
2363
285
        EXPECT_EQ(ROOT_DIR, child.parentIds().at(0).toStdString());
2364
286
        EXPECT_EQ("", child.etag());
2365
287
        EXPECT_EQ(Item::Type::Folder, child.type());
2366
288
        EXPECT_EQ(5, child.metadata().size());
2367
289
2368
290
        struct stat st;
2369
291
        ASSERT_EQ(0, stat(child.itemId().toStdString().c_str(), &st));
2370
292
        EXPECT_TRUE(S_ISDIR(st.st_mode));
2371
293
2372
294
        // Again, to get coverage for a StorageException caught in invoke_async().
2373
295
        job.reset(root.createFolder("child"));
2374
296
        wait(job.get());
2375
297
        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
2376
298
        EXPECT_EQ(string("Exists: create_folder(): \"") + ROOT_DIR + "/child\" exists already",
2377
299
                  job->error().errorString().toStdString());
2378
300
2379
301
        // Again, without write permission on the root dir, to get coverage for a filesystem_error in invoke_async().
2380
302
        ASSERT_EQ(0, ::rmdir((ROOT_DIR + "/child").c_str()));
2381
303
        ASSERT_EQ(0, ::chmod(ROOT_DIR.c_str(), 0555));
2382
304
        job.reset(root.createFolder("child"));
2383
305
        wait(job.get());
2384
306
        ::chmod(ROOT_DIR.c_str(), 0755);
2385
307
        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
2386
308
        EXPECT_EQ(string("PermissionDenied: create_folder(): \"") + ROOT_DIR
2387
309
                  + "/child\": boost::filesystem::create_directory: Permission denied: \"" + ROOT_DIR + "/child\"",
2388
310
                  job->error().errorString().toStdString());
2389
311
    }
2390
312
}
2391
313
2392
314
TEST_F(LocalProviderTest, delete_item)
2393
315
{
2394
316
    {
2395
317
        using namespace unity::storage::qt;
2396
318
2397
319
        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2398
320
2399
321
        auto root = get_root(acc_);
2400
322
        unique_ptr<ItemJob> job(root.createFolder("child"));
2401
323
        wait(job.get());
2402
324
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2403
325
2404
326
        Item child = job->item();
2405
327
        unique_ptr<VoidJob> delete_job(child.deleteItem());
2406
328
        wait(delete_job.get());
2407
329
        ASSERT_EQ(ItemJob::Finished, delete_job->status()) << delete_job->error().errorString().toStdString();
2408
330
2409
331
        struct stat st;
2410
332
        ASSERT_EQ(-1, stat(child.itemId().toStdString().c_str(), &st));
2411
333
        EXPECT_EQ(ENOENT, errno);
2412
334
    }
2413
335
}
2414
336
2415
337
TEST_F(LocalProviderTest, delete_item_noperm)
2416
338
{
2417
339
    {
2418
340
        using namespace unity::storage::qt;
2419
341
2420
342
        set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2421
343
2422
344
        auto root = get_root(acc_);
2423
345
        unique_ptr<ItemJob> job(root.createFolder("child"));
2424
346
        wait(job.get());
2425
347
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2426
348
    }
2427
349
}
2428
350
2429
351
TEST_F(LocalProviderTest, delete_root)
2430
352
{
2431
353
    // Client-side API does not allow us to try to delete the root, so we talk to the provider directly.
2432
354
    auto p = make_shared<LocalProvider>();
2433
355
2434
356
    auto fut = p->delete_item(ROOT_DIR, provider::Context());
2435
357
    try
2436
358
    {
2437
359
        fut.get();
2438
360
        FAIL();
2439
361
    }
2440
362
    catch (provider::LogicException const& e)
2441
363
    {
2442
364
        EXPECT_STREQ("LogicException: delete_item(): cannot delete root", e.what());
2443
365
    }
2444
366
}
2445
367
2446
368
TEST_F(LocalProviderTest, metadata)
2447
369
{
2448
370
    // Client-side API does not call the Metadata DBus method (except as part of parents()),
2449
371
    // so we talk to the provider directly.
2450
372
    auto p = make_shared<LocalProvider>();
2451
373
2452
374
    auto fut = p->metadata(ROOT_DIR, {}, provider::Context());
2453
375
    auto item = fut.get();
2454
376
    EXPECT_EQ(5, item.metadata.size());
2455
377
2456
378
    // Again, to get coverage for the "not file or folder" case in make_item().
2457
379
    ASSERT_EQ(0, mknod((ROOT_DIR + "/pipe").c_str(), S_IFIFO | 06666, 0));
2458
380
    try
2459
381
    {
2460
382
        auto fut = p->metadata(ROOT_DIR + "/pipe", {}, provider::Context());
2461
383
        fut.get();
2462
384
        FAIL();
2463
385
    }
2464
386
    catch (provider::NotExistsException const& e)
2465
387
    {
2466
388
        EXPECT_EQ(string("NotExistsException: metadata(): \"") + ROOT_DIR + "/pipe\" is neither a file nor a folder",
2467
389
                  e.what());
2468
390
    }
2469
391
}
2470
392
2471
393
TEST_F(LocalProviderTest, lookup)
2472
394
{
2473
395
    using namespace unity::storage::qt;
2474
396
2475
397
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2476
398
2477
399
    auto root = get_root(acc_);
2478
400
    {
2479
401
        unique_ptr<ItemJob> job(root.createFolder("child"));
2480
402
        wait(job.get());
2481
403
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2482
404
    }
2483
405
2484
406
    unique_ptr<ItemListJob> job(root.lookup("child"));
2485
407
    auto items = get_items(job.get());
2486
408
    ASSERT_EQ(1, items.size());
2487
409
    auto child = items.at(0);
2488
410
2489
411
    EXPECT_EQ(ROOT_DIR + "/child", child.itemId().toStdString());
2490
412
    EXPECT_EQ("child", child.name().toStdString());
2491
413
    ASSERT_EQ(1, child.parentIds().size());
2492
414
    EXPECT_EQ(ROOT_DIR, child.parentIds().at(0).toStdString());
2493
415
    EXPECT_EQ("", child.etag());
2494
416
    EXPECT_EQ(Item::Type::Folder, child.type());
2495
417
    EXPECT_EQ(5, child.metadata().size());
2496
418
2497
419
    // Remove the child again and try the lookup once more.
2498
420
    ASSERT_EQ(0, rmdir((ROOT_DIR + "/child").c_str()));
2499
421
2500
422
    job.reset(root.lookup("child"));
2501
423
    wait(job.get());
2502
424
    EXPECT_EQ(ItemJob::Error, job->status());
2503
425
    EXPECT_EQ(string("NotExists: lookup(): \"") + ROOT_DIR + "/child\": boost::filesystem::canonical: "
2504
426
              + "No such file or directory: \"" + ROOT_DIR + "/child\"",
2505
427
              job->error().errorString().toStdString());
2506
428
}
2507
429
2508
430
TEST_F(LocalProviderTest, list)
2509
431
{
2510
432
    using namespace unity::storage::qt;
2511
433
2512
434
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2513
435
2514
436
    auto root = get_root(acc_);
2515
437
    {
2516
438
        unique_ptr<ItemJob> job(root.createFolder("child"));
2517
439
        wait(job.get());
2518
440
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2519
441
    }
2520
442
2521
443
    // Make a weird item that will be ignored (for coverage).
2522
444
    ASSERT_EQ(0, mknod((ROOT_DIR + "/pipe").c_str(), S_IFIFO | 06666, 0));
2523
445
2524
446
    // Make a file that starts with the temp file prefix (for coverage).
2525
447
    int fd = creat((ROOT_DIR + "/.storage-framework").c_str(), 0755);
2526
448
    ASSERT_GT(fd, 0);
2527
449
    close(fd);
2528
450
2529
451
    unique_ptr<ItemListJob> job(root.list());
2530
452
    auto items = get_items(job.get());
2531
453
    ASSERT_EQ(1, items.size());
2532
454
    auto child = items.at(0);
2533
455
2534
456
    EXPECT_EQ(ROOT_DIR + "/child", child.itemId().toStdString());
2535
457
    EXPECT_EQ("child", child.name().toStdString());
2536
458
    ASSERT_EQ(1, child.parentIds().size());
2537
459
    EXPECT_EQ(ROOT_DIR, child.parentIds().at(0).toStdString());
2538
460
    EXPECT_EQ("", child.etag());
2539
461
    EXPECT_EQ(Item::Type::Folder, child.type());
2540
462
    EXPECT_EQ(5, child.metadata().size());
2541
463
}
2542
464
2543
465
void make_hierarchy()
2544
466
{
2545
467
    // Make a small tree so we have something to test with for move() and copy().
2546
468
    ASSERT_EQ(0, mkdir((ROOT_DIR + "/a").c_str(), 0755));
2547
469
    ASSERT_EQ(0, mkdir((ROOT_DIR + "/a/b").c_str(), 0755));
2548
470
    string cmd = string("echo hello >") + ROOT_DIR + "/hello";
2549
471
    ASSERT_EQ(0, system(cmd.c_str()));
2550
472
    cmd = string("echo text >") + ROOT_DIR + "/a/foo.txt";
2551
473
    ASSERT_EQ(0, system(cmd.c_str()));
2552
474
    ASSERT_EQ(0, mknod((ROOT_DIR + "/a/pipe").c_str(), S_IFIFO | 06666, 0));
2553
475
    ASSERT_EQ(0, mkdir((ROOT_DIR + "/a/.storage-framework-").c_str(), 0755));
2554
476
    ASSERT_EQ(0, mkdir((ROOT_DIR + "/a/b/.storage-framework-").c_str(), 0755));
2555
477
    ASSERT_EQ(0, mknod((ROOT_DIR + "/a/b/pipe").c_str(), S_IFIFO | 06666, 0));
2556
478
}
2557
479
2558
480
TEST_F(LocalProviderTest, move)
2559
481
{
2560
482
    using namespace unity::storage::qt;
2561
483
2562
484
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2563
485
2564
486
    auto start_time = nanosecs_now();
2565
487
2566
488
    make_hierarchy();
2567
489
2568
490
    auto root = get_root(acc_);
2569
491
2570
492
    qt::Item hello;
2571
493
    {
2572
494
        unique_ptr<ItemListJob> job(root.lookup("hello"));
2573
495
        auto items = get_items(job.get());
2574
496
        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
2575
497
        ASSERT_EQ(1, items.size());
2576
498
        hello = items.at(0);
2577
499
    }
2578
500
2579
501
    struct stat st;
2580
502
    ASSERT_EQ(0, stat(hello.itemId().toStdString().c_str(), &st));
2581
503
    auto old_ino = st.st_ino;
2582
504
2583
505
    // Check metadata.
2584
506
    EXPECT_EQ("hello", hello.name());
2585
507
    ASSERT_EQ(1, hello.parentIds().size());
2586
508
    EXPECT_EQ(ROOT_DIR, hello.parentIds().at(0).toStdString());
2587
509
    EXPECT_EQ(Item::Type::File, hello.type());
2588
510
2589
511
    ASSERT_EQ(6, hello.metadata().size());
2590
512
    auto free_space_bytes = hello.metadata().value("free_space_bytes").toLongLong();
2591
513
    cout << "free_space_bytes: " << free_space_bytes << endl;
2592
514
    EXPECT_GT(free_space_bytes, 0);
2593
515
    auto used_space_bytes = hello.metadata().value("used_space_bytes").toLongLong();
2594
516
    cout << "used_space_bytes: " << used_space_bytes << endl;
2595
517
    EXPECT_GT(used_space_bytes, 0);
2596
518
    auto content_type = hello.metadata().value("content_type").toString();
2597
519
    EXPECT_EQ("application/octet-stream", content_type);
2598
520
    auto writable = hello.metadata().value("writable").toBool();
2599
521
    EXPECT_TRUE(writable);
2600
522
    auto size = hello.metadata().value("size_in_bytes").toLongLong();
2601
523
    EXPECT_EQ(6, size);
2602
524
2603
525
    // yyyy-mm-ddThh:mm:ssZ
2604
526
    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$";
2605
527
    string date_time = hello.metadata().value("last_modified_time").toString().toStdString();
2606
528
    cout << "last_modified_time: " << date_time << endl;
2607
529
    regex re(date_time_fmt);
2608
530
    EXPECT_TRUE(regex_match(date_time, re));
2609
531
2610
532
    // Check that the file was modified in the last two seconds.
2611
533
    // Because the system clock can tick a lot more frequently than the file system time stamp,
2612
534
    // we allow the mtime to be up to one second *earlier* than the time we started the operation.
2613
535
    string mtime_str = hello.etag().toStdString();
2614
536
    char* end;
2615
537
    int64_t mtime = strtoll(mtime_str.c_str(), &end, 10);
2616
538
    EXPECT_LE(start_time - 1000000000, mtime);
2617
539
    EXPECT_LT(mtime, start_time + 2000000000);
2618
540
2619
541
    // Move hello -> world
2620
542
    qt::Item world;
2621
543
    {
2622
544
        unique_ptr<ItemJob> job(hello.move(root, "world"));
2623
545
        wait(job.get());
2624
546
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2625
547
        world = job->item();
2626
548
    }
2627
549
    EXPECT_FALSE(boost::filesystem::exists(hello.itemId().toStdString()));
2628
550
    EXPECT_EQ(ROOT_DIR + "/world", world.itemId().toStdString());
2629
551
2630
552
    ASSERT_EQ(0, stat(world.itemId().toStdString().c_str(), &st));
2631
553
    auto new_ino = st.st_ino;
2632
554
    EXPECT_EQ(old_ino, new_ino);
2633
555
2634
556
    // For coverage: try moving world -> a (which must fail)
2635
557
    unique_ptr<ItemJob> job(world.move(root, "a"));
2636
558
    wait(job.get());
2637
559
    ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
2638
560
    EXPECT_EQ(string("Exists: move(): \"") + ROOT_DIR + "/a\" exists already",
2639
561
              job->error().errorString().toStdString());
2640
562
}
2641
563
2642
564
TEST_F(LocalProviderTest, copy_file)
2643
565
{
2644
566
    using namespace unity::storage::qt;
2645
567
2646
568
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2647
569
2648
570
    make_hierarchy();
2649
571
2650
572
    auto root = get_root(acc_);
2651
573
2652
574
    // Copy hello -> world
2653
575
    qt::Item hello;
2654
576
    {
2655
577
        unique_ptr<ItemListJob> job(root.lookup("hello"));
2656
578
        auto items = get_items(job.get());
2657
579
        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
2658
580
        ASSERT_EQ(1, items.size());
2659
581
        hello = items.at(0);
2660
582
    }
2661
583
2662
584
    struct stat st;
2663
585
    ASSERT_EQ(0, stat(hello.itemId().toStdString().c_str(), &st));
2664
586
    auto old_ino = st.st_ino;
2665
587
2666
588
    qt::Item world;
2667
589
    {
2668
590
        unique_ptr<ItemJob> job(hello.copy(root, "world"));
2669
591
        wait(job.get());
2670
592
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2671
593
        world = job->item();
2672
594
    }
2673
595
    EXPECT_TRUE(boost::filesystem::exists(hello.itemId().toStdString()));
2674
596
    EXPECT_EQ(ROOT_DIR + "/world", world.itemId().toStdString());
2675
597
2676
598
    ASSERT_EQ(0, stat(world.itemId().toStdString().c_str(), &st));
2677
599
    auto new_ino = st.st_ino;
2678
600
    EXPECT_NE(old_ino, new_ino);
2679
601
}
2680
602
2681
603
TEST_F(LocalProviderTest, copy_tree)
2682
604
{
2683
605
    using namespace unity::storage::qt;
2684
606
    using namespace boost::filesystem;
2685
607
2686
608
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2687
609
2688
610
    make_hierarchy();
2689
611
2690
612
    auto root = get_root(acc_);
2691
613
2692
614
    // Copy a -> c
2693
615
    qt::Item a;
2694
616
    {
2695
617
        unique_ptr<ItemListJob> job(root.lookup("a"));
2696
618
        auto items = get_items(job.get());
2697
619
        ASSERT_EQ(ItemListJob::Finished, job->status()) << job->error().errorString().toStdString();
2698
620
        ASSERT_EQ(1, items.size());
2699
621
        a = items.at(0);
2700
622
    }
2701
623
2702
624
    qt::Item c;
2703
625
    {
2704
626
        unique_ptr<ItemJob> job(a.copy(root, "c"));
2705
627
        wait(job.get());
2706
628
        ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2707
629
        c = job->item();
2708
630
    }
2709
631
    EXPECT_TRUE(exists(c.itemId().toStdString()));
2710
632
2711
633
    // Check that we only copied regular files and directories, but not a pipe or anything starting with
2712
634
    // the temp file prefix.
2713
635
    EXPECT_TRUE(exists(ROOT_DIR + "/c/b"));
2714
636
    EXPECT_TRUE(exists(ROOT_DIR + "/c/foo.txt"));
2715
637
    EXPECT_FALSE(exists(ROOT_DIR + "/c/pipe"));
2716
638
    EXPECT_FALSE(exists(ROOT_DIR + "/c/storage-framework-"));
2717
639
    EXPECT_FALSE(exists(ROOT_DIR + "/c/b/pipe"));
2718
640
    EXPECT_FALSE(exists(ROOT_DIR + "/c/b/storage-framework-"));
2719
641
2720
642
    // Copy c -> a. This must fail because a exists.
2721
643
    {
2722
644
        unique_ptr<ItemJob> job(c.copy(root, "a"));
2723
645
        wait(job.get());
2724
646
        ASSERT_EQ(ItemJob::Error, job->status()) << job->error().errorString().toStdString();
2725
647
        EXPECT_EQ(string("Exists: copy(): \"") + ROOT_DIR + "/a\" exists already",
2726
648
                  job->error().errorString().toStdString());
2727
649
    }
2728
650
}
2729
651
2730
652
TEST_F(LocalProviderTest, download)
2731
653
{
2732
654
    using namespace unity::storage::qt;
2733
655
2734
656
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2735
657
2736
658
    int const segments = 10000;
2737
659
    string large_contents;
2738
660
    large_contents.reserve(file_contents.size() * segments);
2739
661
    for (int i = 0; i < segments; i++)
2740
662
    {
2741
663
        large_contents += file_contents;
2742
664
    }
2743
665
    string const full_path = ROOT_DIR + "/foo.txt";
2744
666
    {
2745
667
        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
2746
668
        ASSERT_GT(fd, 0);
2747
669
        ASSERT_EQ(ssize_t(large_contents.size()), write(fd, &large_contents[0], large_contents.size())) << strerror(errno);
2748
670
        ASSERT_EQ(0, close(fd));
2749
671
    }
2750
672
2751
673
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2752
674
    wait(job.get());
2753
675
    EXPECT_TRUE(job->isValid());
2754
676
2755
677
    auto file = job->item();
2756
678
    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
2757
679
2758
680
    int64_t n_read = 0;
2759
681
    QObject::connect(downloader.get(), &QIODevice::readyRead,
2760
682
                     [&]() {
2761
683
                         auto bytes = downloader->readAll();
2762
684
                         string const expected = large_contents.substr(n_read, bytes.size());
2763
685
                         EXPECT_EQ(expected, bytes.toStdString());
2764
686
                         n_read += bytes.size();
2765
687
                     });
2766
688
    QSignalSpy read_finished_spy(downloader.get(), &QIODevice::readChannelFinished);
2767
689
    ASSERT_TRUE(read_finished_spy.wait(SIGNAL_WAIT_TIME));
2768
690
2769
691
    QSignalSpy status_spy(downloader.get(), &Downloader::statusChanged);
2770
692
    downloader->close();
2771
693
    while (downloader->status() == Downloader::Ready)
2772
694
    {
2773
695
        ASSERT_TRUE(status_spy.wait(SIGNAL_WAIT_TIME));
2774
696
    }
2775
697
    ASSERT_EQ(Downloader::Finished, downloader->status()) << downloader->error().errorString().toStdString();
2776
698
2777
699
    EXPECT_EQ(int64_t(large_contents.size()), n_read);
2778
700
}
2779
701
2780
702
TEST_F(LocalProviderTest, download_short_read)
2781
703
{
2782
704
    using namespace unity::storage::qt;
2783
705
2784
706
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2785
707
2786
708
    int const segments = 10000;
2787
709
    string const full_path = ROOT_DIR + "/foo.txt";
2788
710
    {
2789
711
        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
2790
712
        ASSERT_GT(fd, 0);
2791
713
        for (int i = 0; i < segments; i++)
2792
714
        {
2793
715
            ASSERT_EQ(ssize_t(file_contents.size()), write(fd, &file_contents[0], file_contents.size())) << strerror(errno);
2794
716
        }
2795
717
        ASSERT_EQ(0, close(fd));
2796
718
    }
2797
719
2798
720
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2799
721
    wait(job.get());
2800
722
    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2801
723
2802
724
    auto file = job->item();
2803
725
    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
2804
726
2805
727
    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
2806
728
    while (downloader->status() == Downloader::Loading)
2807
729
    {
2808
730
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2809
731
    }
2810
732
2811
733
    downloader->close();
2812
734
    while (downloader->status() == Downloader::Ready)
2813
735
    {
2814
736
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2815
737
    }
2816
738
    ASSERT_EQ(Downloader::Error, downloader->status()) << downloader->error().errorString().toStdString();
2817
739
2818
740
    auto error = downloader->error();
2819
741
    EXPECT_EQ(qt::StorageError::LogicError, error.type());
2820
742
    cout << error.message().toStdString() << endl;
2821
743
    EXPECT_TRUE(boost::starts_with(error.message().toStdString(),
2822
744
                                   "finish() method called too early, file \""
2823
745
                                   + full_path + "\" has size 4460000 but only"));
2824
746
}
2825
747
2826
748
TEST_F(LocalProviderTest, download_etag_mismatch)
2827
749
{
2828
750
    using namespace unity::storage::qt;
2829
751
2830
752
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2831
753
2832
754
    string const full_path = ROOT_DIR + "/foo.txt";
2833
755
    string cmd = string("echo hello >") + full_path;
2834
756
    ASSERT_EQ(0, system(cmd.c_str()));
2835
757
2836
758
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2837
759
    wait(job.get());
2838
760
    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2839
761
2840
762
    auto file = job->item();
2841
763
2842
764
    sleep(1);
2843
765
    cmd = string("touch ") + full_path;
2844
766
    ASSERT_EQ(0, system(cmd.c_str()));
2845
767
2846
768
    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
2847
769
2848
770
    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
2849
771
    while (downloader->status() != Downloader::Error)
2850
772
    {
2851
773
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2852
774
    }
2853
775
2854
776
    auto error = downloader->error();
2855
777
    EXPECT_EQ(qt::StorageError::Conflict, error.type());
2856
778
    EXPECT_EQ("download(): etag mismatch", error.message().toStdString());
2857
779
}
2858
780
2859
781
TEST_F(LocalProviderTest, download_wrong_file_type)
2860
782
{
2861
783
    // We can't try a download for a directory via the client API, so we use the LocalDownloadJob directly.
2862
784
2863
785
    auto p = make_shared<LocalProvider>();
2864
786
2865
787
    string const dir = ROOT_DIR + "/dir";
2866
788
    ASSERT_EQ(0, mkdir(dir.c_str(), 0755));
2867
789
2868
790
    try
2869
791
    {
2870
792
        LocalDownloadJob(p, dir, "some_etag");
2871
793
        FAIL();
2872
794
    }
2873
795
    catch (provider::InvalidArgumentException const& e)
2874
796
    {
2875
797
        EXPECT_EQ(string("InvalidArgumentException: download(): \"" + dir + "\" is not a file"), e.what());
2876
798
    }
2877
799
}
2878
800
2879
801
TEST_F(LocalProviderTest, download_no_permission)
2880
802
{
2881
803
    using namespace unity::storage::qt;
2882
804
2883
805
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2884
806
2885
807
    string const full_path = ROOT_DIR + "/foo.txt";
2886
808
    string cmd = string("echo hello >") + full_path;
2887
809
    ASSERT_EQ(0, system(cmd.c_str()));
2888
810
2889
811
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2890
812
    wait(job.get());
2891
813
    ASSERT_EQ(ItemJob::Finished, job->status()) << job->error().errorString().toStdString();
2892
814
2893
815
    auto file = job->item();
2894
816
2895
817
    ASSERT_EQ(0, chmod(full_path.c_str(), 0244));
2896
818
2897
819
    unique_ptr<Downloader> downloader(file.createDownloader(Item::ErrorIfConflict));
2898
820
2899
821
    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
2900
822
    while (downloader->status() != Downloader::Error)
2901
823
    {
2902
824
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2903
825
    }
2904
826
2905
827
    auto error = downloader->error();
2906
828
    EXPECT_EQ(qt::StorageError::ResourceError, error.type());
2907
829
    EXPECT_EQ(string("download(): : cannot open \"") + full_path + "\": Permission denied (QFileDevice::FileError = 5)",
2908
830
              error.message().toStdString());
2909
831
}
2910
832
2911
833
TEST_F(LocalProviderTest, download_no_such_file)
2912
834
{
2913
835
    // We can't try a download for a non-existent file via the client API, so we use the LocalDownloadJob directly.
2914
836
2915
837
    auto p = make_shared<LocalProvider>();
2916
838
2917
839
    try
2918
840
    {
2919
841
        LocalDownloadJob(p, ROOT_DIR + "/no_such_file", "some_etag");
2920
842
        FAIL();
2921
843
    }
2922
844
    catch (provider::NotExistsException const&)
2923
845
    {
2924
846
    }
2925
847
}
2926
848
2927
849
TEST_F(LocalProviderTest, update)
2928
850
{
2929
851
    using namespace unity::storage::qt;
2930
852
2931
853
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2932
854
2933
855
    auto full_path = ROOT_DIR + "/foo.txt";
2934
856
    auto cmd = string("echo hello >") + full_path;
2935
857
    ASSERT_EQ(0, system(cmd.c_str()));
2936
858
2937
859
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2938
860
    wait(job.get());
2939
861
    EXPECT_TRUE(job->isValid());
2940
862
2941
863
    auto file = job->item();
2942
864
    auto old_etag = file.etag();
2943
865
2944
866
    int const segments = 50;
2945
867
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
2946
868
2947
869
    int count = 0;
2948
870
    QTimer timer;
2949
871
    timer.setSingleShot(false);
2950
872
    timer.setInterval(10);
2951
873
    QObject::connect(&timer, &QTimer::timeout, [&] {
2952
874
            uploader->write(&file_contents[0], file_contents.size());
2953
875
            count++;
2954
876
            if (count == segments)
2955
877
            {
2956
878
                uploader->close();
2957
879
            }
2958
880
        });
2959
881
2960
882
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
2961
883
    timer.start();
2962
884
    while (uploader->status() == Uploader::Loading ||
2963
885
           uploader->status() == Uploader::Ready)
2964
886
    {
2965
887
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2966
888
    }
2967
889
    ASSERT_EQ(Uploader::Finished, uploader->status()) << uploader->error().errorString().toStdString();
2968
890
2969
891
    file = uploader->item();
2970
892
    EXPECT_NE(old_etag, file.etag());
2971
893
    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
2972
894
}
2973
895
2974
896
TEST_F(LocalProviderTest, update_empty)
2975
897
{
2976
898
    using namespace unity::storage::qt;
2977
899
2978
900
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
2979
901
2980
902
    auto full_path = ROOT_DIR + "/foo.txt";
2981
903
    auto cmd = string("echo hello >") + full_path;
2982
904
    ASSERT_EQ(0, system(cmd.c_str()));
2983
905
2984
906
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
2985
907
    wait(job.get());
2986
908
    EXPECT_TRUE(job->isValid());
2987
909
2988
910
    auto file = job->item();
2989
911
    auto old_etag = file.etag();
2990
912
2991
913
    sleep(1);  // Make sure mtime changes.
2992
914
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, 0));
2993
915
    {
2994
916
        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
2995
917
        while (uploader->status() != Uploader::Ready)
2996
918
        {
2997
919
            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
2998
920
        }
2999
921
    }
3000
922
3001
923
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3002
924
    uploader->close();
3003
925
    while (uploader->status() != Uploader::Finished)
3004
926
    {
3005
927
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3006
928
    }
3007
929
3008
930
    file = uploader->item();
3009
931
    EXPECT_NE(old_etag, file.etag());
3010
932
    EXPECT_EQ(int64_t(0), file.sizeInBytes());
3011
933
}
3012
934
3013
935
TEST_F(LocalProviderTest, update_cancel)
3014
936
{
3015
937
    using namespace unity::storage::qt;
3016
938
3017
939
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3018
940
3019
941
    auto full_path = ROOT_DIR + "/foo.txt";
3020
942
    auto cmd = string("echo hello >") + full_path;
3021
943
    ASSERT_EQ(0, system(cmd.c_str()));
3022
944
3023
945
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3024
946
    wait(job.get());
3025
947
    EXPECT_TRUE(job->isValid());
3026
948
3027
949
    auto file = job->item();
3028
950
    auto old_etag = file.etag();
3029
951
3030
952
    int const segments = 50;
3031
953
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
3032
954
3033
955
    int count = 0;
3034
956
    QTimer timer;
3035
957
    timer.setSingleShot(false);
3036
958
    timer.setInterval(10);
3037
959
    QObject::connect(&timer, &QTimer::timeout, [&] {
3038
960
            uploader->write(&file_contents[0], file_contents.size());
3039
961
            count++;
3040
962
            if (count == segments / 2)
3041
963
            {
3042
964
                uploader->cancel();
3043
965
            }
3044
966
            else if (count == segments)
3045
967
            {
3046
968
                uploader->close();
3047
969
            }
3048
970
        });
3049
971
3050
972
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3051
973
    timer.start();
3052
974
    while (uploader->status() != Uploader::Cancelled)
3053
975
    {
3054
976
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3055
977
    }
3056
978
}
3057
979
3058
980
TEST_F(LocalProviderTest, update_file_touched_before_uploading)
3059
981
{
3060
982
    using namespace unity::storage::qt;
3061
983
3062
984
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3063
985
3064
986
    auto full_path = ROOT_DIR + "/foo.txt";
3065
987
    auto cmd = string("echo hello >") + full_path;
3066
988
    ASSERT_EQ(0, system(cmd.c_str()));
3067
989
3068
990
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3069
991
    wait(job.get());
3070
992
    EXPECT_TRUE(job->isValid());
3071
993
3072
994
    auto file = job->item();
3073
995
    auto old_etag = file.etag();
3074
996
3075
997
    sleep(1);  // Make sure mtime changes.
3076
998
    cmd = string("touch ") + full_path;
3077
999
    ASSERT_EQ(0, system(cmd.c_str()));
3078
1000
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, 0));
3079
1001
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3080
1002
    while (uploader->status() != Uploader::Error)
3081
1003
    {
3082
1004
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3083
1005
    }
3084
1006
    EXPECT_EQ("update(): etag mismatch", uploader->error().message().toStdString());
3085
1007
}
3086
1008
3087
1009
TEST_F(LocalProviderTest, update_file_touched_while_uploading)
3088
1010
{
3089
1011
    using namespace unity::storage::qt;
3090
1012
3091
1013
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3092
1014
3093
1015
    auto full_path = ROOT_DIR + "/foo.txt";
3094
1016
    auto cmd = string("echo hello >") + full_path;
3095
1017
    ASSERT_EQ(0, system(cmd.c_str()));
3096
1018
3097
1019
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3098
1020
    wait(job.get());
3099
1021
    EXPECT_TRUE(job->isValid());
3100
1022
3101
1023
    auto file = job->item();
3102
1024
    auto old_etag = file.etag();
3103
1025
3104
1026
    int const segments = 50;
3105
1027
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
3106
1028
3107
1029
    int count = 0;
3108
1030
    QTimer timer;
3109
1031
    timer.setSingleShot(false);
3110
1032
    timer.setInterval(10);
3111
1033
    QObject::connect(&timer, &QTimer::timeout, [&] {
3112
1034
            uploader->write(&file_contents[0], file_contents.size());
3113
1035
            count++;
3114
1036
            if (count == segments / 2)
3115
1037
            {
3116
1038
                sleep(1);
3117
1039
                cmd = string("touch ") + full_path;
3118
1040
                ASSERT_EQ(0, system(cmd.c_str()));
3119
1041
            }
3120
1042
            else if (count == segments)
3121
1043
            {
3122
1044
                uploader->close();
3123
1045
            }
3124
1046
        });
3125
1047
3126
1048
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3127
1049
    timer.start();
3128
1050
    while (uploader->status() != Uploader::Error)
3129
1051
    {
3130
1052
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3131
1053
    }
3132
1054
    ASSERT_EQ(Uploader::Error, uploader->status());
3133
1055
    EXPECT_EQ("update(): etag mismatch", uploader->error().message().toStdString());
3134
1056
}
3135
1057
3136
1058
TEST_F(LocalProviderTest, update_ignore_etag_mismatch)
3137
1059
{
3138
1060
    using namespace unity::storage::qt;
3139
1061
3140
1062
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3141
1063
3142
1064
    auto full_path = ROOT_DIR + "/foo.txt";
3143
1065
    auto cmd = string("echo hello >") + full_path;
3144
1066
    ASSERT_EQ(0, system(cmd.c_str()));
3145
1067
3146
1068
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3147
1069
    wait(job.get());
3148
1070
    EXPECT_TRUE(job->isValid());
3149
1071
3150
1072
    auto file = job->item();
3151
1073
    auto old_etag = file.etag();
3152
1074
3153
1075
    sleep(1);  // Make sure mtime changes.
3154
1076
    cmd = string("touch ") + full_path;
3155
1077
    unique_ptr<Uploader> uploader(file.createUploader(Item::IgnoreConflict, 0));
3156
1078
    {
3157
1079
        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3158
1080
        while (uploader->status() != Uploader::Ready)
3159
1081
        {
3160
1082
            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3161
1083
        }
3162
1084
    }
3163
1085
3164
1086
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3165
1087
    uploader->close();
3166
1088
    while (uploader->status() != Uploader::Finished)
3167
1089
    {
3168
1090
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3169
1091
    }
3170
1092
3171
1093
    file = uploader->item();
3172
1094
    EXPECT_NE(old_etag, file.etag());
3173
1095
    EXPECT_EQ(int64_t(0), file.sizeInBytes());
3174
1096
}
3175
1097
3176
1098
TEST_F(LocalProviderTest, update_close_too_soon)
3177
1099
{
3178
1100
    using namespace unity::storage::qt;
3179
1101
3180
1102
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3181
1103
3182
1104
    auto full_path = ROOT_DIR + "/foo.txt";
3183
1105
    auto cmd = string("echo hello >") + full_path;
3184
1106
    ASSERT_EQ(0, system(cmd.c_str()));
3185
1107
3186
1108
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3187
1109
    wait(job.get());
3188
1110
    EXPECT_TRUE(job->isValid());
3189
1111
3190
1112
    auto file = job->item();
3191
1113
    auto old_etag = file.etag();
3192
1114
3193
1115
    int const segments = 50;
3194
1116
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments));
3195
1117
3196
1118
    int count = 0;
3197
1119
    QTimer timer;
3198
1120
    timer.setSingleShot(false);
3199
1121
    timer.setInterval(10);
3200
1122
    QObject::connect(&timer, &QTimer::timeout, [&] {
3201
1123
            uploader->write(&file_contents[0], file_contents.size());
3202
1124
            count++;
3203
1125
            if (count == segments - 1)
3204
1126
            {
3205
1127
                uploader->close();
3206
1128
            }
3207
1129
        });
3208
1130
3209
1131
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3210
1132
    timer.start();
3211
1133
    while (uploader->status() != Uploader::Error)
3212
1134
    {
3213
1135
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3214
1136
    }
3215
1137
    ASSERT_EQ(Uploader::Error, uploader->status()) << uploader->error().errorString().toStdString();
3216
1138
    EXPECT_EQ("LogicError: finish() method called too early, size was given as 22300 but only 21854 bytes were received",
3217
1139
              uploader->error().errorString().toStdString());
3218
1140
}
3219
1141
3220
1142
TEST_F(LocalProviderTest, update_write_too_much)
3221
1143
{
3222
1144
    using namespace unity::storage::qt;
3223
1145
3224
1146
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3225
1147
3226
1148
    auto full_path = ROOT_DIR + "/foo.txt";
3227
1149
    auto cmd = string("echo hello >") + full_path;
3228
1150
    ASSERT_EQ(0, system(cmd.c_str()));
3229
1151
3230
1152
    unique_ptr<ItemJob> job(acc_.get(QString::fromStdString(full_path)));
3231
1153
    wait(job.get());
3232
1154
    EXPECT_TRUE(job->isValid());
3233
1155
3234
1156
    auto file = job->item();
3235
1157
    auto old_etag = file.etag();
3236
1158
3237
1159
    int const segments = 50;
3238
1160
    // We write more than this many bytes below.
3239
1161
    unique_ptr<Uploader> uploader(file.createUploader(Item::ErrorIfConflict, file_contents.size() * segments - 1));
3240
1162
3241
1163
    int count = 0;
3242
1164
    QTimer timer;
3243
1165
    timer.setSingleShot(false);
3244
1166
    timer.setInterval(10);
3245
1167
    QObject::connect(&timer, &QTimer::timeout, [&] {
3246
1168
            uploader->write(&file_contents[0], file_contents.size());
3247
1169
            count++;
3248
1170
            if (count == segments)
3249
1171
            {
3250
1172
                uploader->close();
3251
1173
            }
3252
1174
        });
3253
1175
3254
1176
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3255
1177
    timer.start();
3256
1178
    while (uploader->status() != Uploader::Error)
3257
1179
    {
3258
1180
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3259
1181
    }
3260
1182
    ASSERT_EQ(Uploader::Error, uploader->status());
3261
1183
    EXPECT_EQ("update(): received more than the expected number (22299) of bytes",
3262
1184
              uploader->error().message().toStdString());
3263
1185
}
3264
1186
3265
1187
TEST_F(LocalProviderTest, upload_wrong_file_type)
3266
1188
{
3267
1189
    // We can't try an upload for a directory via the client API, so we use the LocalUploadJob directly.
3268
1190
3269
1191
    auto p = make_shared<LocalProvider>();
3270
1192
3271
1193
    string const dir = ROOT_DIR + "/dir";
3272
1194
    ASSERT_EQ(0, mkdir(dir.c_str(), 0755));
3273
1195
3274
1196
    try
3275
1197
    {
3276
1198
        LocalUploadJob(p, dir, 0, "");
3277
1199
        FAIL();
3278
1200
    }
3279
1201
    catch (provider::InvalidArgumentException const& e)
3280
1202
    {
3281
1203
        EXPECT_EQ(string("InvalidArgumentException: update(): \"" + dir + "\" is not a file"), e.what());
3282
1204
    }
3283
1205
}
3284
1206
3285
1207
TEST_F(LocalProviderTest, upload_root_noperm)
3286
1208
{
3287
1209
    // Force an error in prepare_channels when creating temp file.
3288
1210
3289
1211
    auto p = make_shared<LocalProvider>();
3290
1212
3291
1213
    ASSERT_EQ(0, chmod(ROOT_DIR.c_str(), 0644));
3292
1214
3293
1215
    try
3294
1216
    {
3295
1217
        LocalUploadJob(p, ROOT_DIR, "name", 0, true);
3296
1218
        chmod(ROOT_DIR.c_str(), 0755);
3297
1219
        FAIL();
3298
1220
    }
3299
1221
    catch (provider::ResourceException const& e)
3300
1222
    {
3301
1223
        EXPECT_EQ(string("ResourceException: create_file(): cannot create temp file \"") + ROOT_DIR
3302
1224
                         + "/.storage-framework-%%%%-%%%%-%%%%-%%%%\": Invalid argument",
3303
1225
                  e.what());
3304
1226
    }
3305
1227
    chmod(ROOT_DIR.c_str(), 0755);
3306
1228
}
3307
1229
3308
1230
TEST_F(LocalProviderTest, sanitize)
3309
1231
{
3310
1232
    // Force various errors in sanitize() for coverage.
3311
1233
3312
1234
    auto p = make_shared<LocalProvider>();
3313
1235
3314
1236
    try
3315
1237
    {
3316
1238
        LocalUploadJob(p, ROOT_DIR, "a/b", 0, true);
3317
1239
        FAIL();
3318
1240
    }
3319
1241
    catch (provider::InvalidArgumentException const& e)
3320
1242
    {
3321
1243
        EXPECT_STREQ("InvalidArgumentException: create_file(): name \"a/b\" cannot contain a slash", e.what());
3322
1244
    }
3323
1245
3324
1246
    try
3325
1247
    {
3326
1248
        LocalUploadJob(p, ROOT_DIR, "..", 0, true);
3327
1249
        FAIL();
3328
1250
    }
3329
1251
    catch (provider::InvalidArgumentException const& e)
3330
1252
    {
3331
1253
        EXPECT_STREQ("InvalidArgumentException: create_file(): invalid name: \"..\"", e.what());
3332
1254
    }
3333
1255
3334
1256
    try
3335
1257
    {
3336
1258
        LocalUploadJob(p, ROOT_DIR, ".storage-framework", 0, true);
3337
1259
        FAIL();
3338
1260
    }
3339
1261
    catch (provider::InvalidArgumentException const& e)
3340
1262
    {
3341
1263
        EXPECT_STREQ("InvalidArgumentException: create_file(): names beginning with \".storage-framework\" are reserved",
3342
1264
                     e.what());
3343
1265
    }
3344
1266
}
3345
1267
3346
1268
TEST_F(LocalProviderTest, throw_if_not_valid)
3347
1269
{
3348
1270
    // Make sure that we can't escape the root.
3349
1271
3350
1272
    auto p = make_shared<LocalProvider>();
3351
1273
3352
1274
    try
3353
1275
    {
3354
1276
        LocalUploadJob(p, ROOT_DIR + "/..", "a", 0, true);
3355
1277
        FAIL();
3356
1278
    }
3357
1279
    catch (provider::InvalidArgumentException const& e)
3358
1280
    {
3359
1281
        EXPECT_EQ(string("InvalidArgumentException: create_file(): invalid id: \"") + ROOT_DIR + "/..\"", e.what());
3360
1282
    }
3361
1283
3362
1284
    try
3363
1285
    {
3364
1286
        LocalUploadJob(p, "/bin" , "a", 0, true);
3365
1287
        FAIL();
3366
1288
    }
3367
1289
    catch (provider::InvalidArgumentException const& e)
3368
1290
    {
3369
1291
        EXPECT_STREQ("InvalidArgumentException: create_file(): invalid id: \"/bin\"", e.what());
3370
1292
    }
3371
1293
}
3372
1294
3373
1295
TEST_F(LocalProviderTest, create_file)
3374
1296
{
3375
1297
    using namespace unity::storage::qt;
3376
1298
3377
1299
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3378
1300
3379
1301
    auto root = get_root(acc_);
3380
1302
    int const segments = 50;
3381
1303
    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
3382
1304
                                                  file_contents.size() * segments, "text/plain"));
3383
1305
3384
1306
    int count = 0;
3385
1307
    QTimer timer;
3386
1308
    timer.setSingleShot(false);
3387
1309
    timer.setInterval(10);
3388
1310
    QObject::connect(&timer, &QTimer::timeout, [&] {
3389
1311
            uploader->write(&file_contents[0], file_contents.size());
3390
1312
            count++;
3391
1313
            if (count == segments)
3392
1314
            {
3393
1315
                uploader->close();
3394
1316
            }
3395
1317
        });
3396
1318
3397
1319
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3398
1320
    while (uploader->status() != Uploader::Ready)
3399
1321
    {
3400
1322
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3401
1323
    }
3402
1324
    timer.start();
3403
1325
    while (uploader->status() != Uploader::Finished)
3404
1326
    {
3405
1327
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3406
1328
    }
3407
1329
3408
1330
    auto file = uploader->item();
3409
1331
    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
3410
1332
}
3411
1333
3412
1334
TEST_F(LocalProviderTest, create_file_ignore_conflict)
3413
1335
{
3414
1336
    using namespace unity::storage::qt;
3415
1337
3416
1338
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3417
1339
3418
1340
    auto full_path = ROOT_DIR + "/foo.txt";
3419
1341
    auto cmd = string("echo hello >") + full_path;
3420
1342
    ASSERT_EQ(0, system(cmd.c_str()));
3421
1343
3422
1344
    auto root = get_root(acc_);
3423
1345
    int const segments = 50;
3424
1346
    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::IgnoreConflict,
3425
1347
                                                  file_contents.size() * segments, "text/plain"));
3426
1348
3427
1349
    int count = 0;
3428
1350
    QTimer timer;
3429
1351
    timer.setSingleShot(false);
3430
1352
    timer.setInterval(10);
3431
1353
    QObject::connect(&timer, &QTimer::timeout, [&] {
3432
1354
            uploader->write(&file_contents[0], file_contents.size());
3433
1355
            count++;
3434
1356
            if (count == segments)
3435
1357
            {
3436
1358
                uploader->close();
3437
1359
            }
3438
1360
        });
3439
1361
3440
1362
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3441
1363
    while (uploader->status() != Uploader::Ready)
3442
1364
    {
3443
1365
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3444
1366
    }
3445
1367
    timer.start();
3446
1368
    while (uploader->status() != Uploader::Finished)
3447
1369
    {
3448
1370
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3449
1371
    }
3450
1372
3451
1373
    auto file = uploader->item();
3452
1374
    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
3453
1375
}
3454
1376
3455
1377
TEST_F(LocalProviderTest, create_file_error_if_conflict)
3456
1378
{
3457
1379
    using namespace unity::storage::qt;
3458
1380
3459
1381
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3460
1382
3461
1383
    auto full_path = ROOT_DIR + "/foo.txt";
3462
1384
    auto cmd = string("echo hello >") + full_path;
3463
1385
    ASSERT_EQ(0, system(cmd.c_str()));
3464
1386
3465
1387
    auto root = get_root(acc_);
3466
1388
    int const segments = 50;
3467
1389
    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
3468
1390
                                                  file_contents.size() * segments, "text/plain"));
3469
1391
3470
1392
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3471
1393
    while (uploader->status() != Uploader::Error)
3472
1394
    {
3473
1395
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3474
1396
    }
3475
1397
    EXPECT_EQ(string("create_file(): \"") + full_path + "\" exists already",
3476
1398
              uploader->error().message().toStdString());
3477
1399
}
3478
1400
3479
1401
TEST_F(LocalProviderTest, create_file_created_during_upload)
3480
1402
{
3481
1403
    using namespace unity::storage::qt;
3482
1404
3483
1405
    set_provider(unique_ptr<provider::ProviderBase>(new LocalProvider));
3484
1406
3485
1407
    auto root = get_root(acc_);
3486
1408
    int const segments = 50;
3487
1409
    string full_path = ROOT_DIR + "/foo.txt";
3488
1410
    unique_ptr<Uploader> uploader(root.createFile("foo.txt", Item::ErrorIfConflict,
3489
1411
                                                  file_contents.size() * segments, "text/plain"));
3490
1412
3491
1413
    int count = 0;
3492
1414
    QTimer timer;
3493
1415
    timer.setSingleShot(false);
3494
1416
    timer.setInterval(10);
3495
1417
    QObject::connect(&timer, &QTimer::timeout, [&] {
3496
1418
            uploader->write(&file_contents[0], file_contents.size());
3497
1419
            count++;
3498
1420
            if (count == segments / 2)
3499
1421
            {
3500
1422
                string cmd = "touch " + full_path;
3501
1423
                ASSERT_EQ(0, system(cmd.c_str()));
3502
1424
            }
3503
1425
            else if (count == segments)
3504
1426
            {
3505
1427
                uploader->close();
3506
1428
            }
3507
1429
        });
3508
1430
3509
1431
    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
3510
1432
    while (uploader->status() != Uploader::Ready)
3511
1433
    {
3512
1434
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3513
1435
    }
3514
1436
    timer.start();
3515
1437
    while (uploader->status() != Uploader::Error)
3516
1438
    {
3517
1439
        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
3518
1440
    }
3519
1441
    EXPECT_EQ(string("create_file(): \"") + full_path + "\" exists already",
3520
1442
              uploader->error().message().toStdString());
3521
1443
}
3522
1444
3523
1445
int main(int argc, char** argv)
3524
1446
{
3525
1447
    setenv("LANG", "C", true);
3526
1448
    setenv("SF_LOCAL_PROVIDER_ROOT", ROOT_DIR.c_str(), true);
3527
1449
3528
1450
    // Test test fixture repeatedly creates and tears down the dbus connection.
3529
1451
    // The provider calls g_file_new_for_path() which talks to the GVfs backend
3530
1452
    // via dbus. If the dbus connection disappears, that causes GIO to send a
3531
1453
    // a SIGTERM, killing the test.
3532
1454
    // Setting GIO_USE_VFS variable to "local" disables sending the signal.
3533
1455
    setenv("GIO_USE_VFS", "local", true);
3534
1456
3535
1457
    QCoreApplication app(argc, argv);
3536
1458
3537
1459
    ::testing::InitGoogleTest(&argc, argv);
3538
1460
    int rc = RUN_ALL_TESTS();
3539
1461
3540
1462
    // Process any pending events to avoid bogus leak reports from valgrind.
3541
1463
    QCoreApplication::sendPostedEvents();
3542
1464
    QCoreApplication::processEvents();
3543
1465
3544
1466
    if (rc == 0)
3545
1467
    {
3546
1468
        boost::system::error_code ec;
3547
1469
        boost::filesystem::remove_all(ROOT_DIR, ec);
3548
1470
    }
3549
1471
3550
1472
    return rc;
3551
1473
}
3552
0
1474
3553
=== added file 'tests/utils/env_var_guard.h'
3554
--- tests/utils/env_var_guard.h	1970-01-01 00:00:00 +0000
3555
+++ tests/utils/env_var_guard.h	2017-03-17 05:04:57 +0000
3556
@@ -0,0 +1,70 @@
3557
1
/*
3558
2
 * Copyright (C) 2015 Canonical Ltd.
3559
3
 *
3560
4
 * This program is free software: you can redistribute it and/or modify
3561
5
 * it under the terms of the GNU General Public License version 3 as
3562
6
 * published by the Free Software Foundation.
3563
7
 *
3564
8
 * This program is distributed in the hope that it will be useful,
3565
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3566
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3567
11
 * GNU General Public License for more details.
3568
12
 *
3569
13
 * You should have received a copy of the GNU General Public License
3570
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3571
15
 *
3572
16
 * Authored by: Michi Henning <michi.henning@canonical.com>
3573
17
 */
3574
18
3575
19
#pragma once
3576
20
3577
21
#include <cassert>
3578
22
#include <cstdlib>
3579
23
#include <string>
3580
24
3581
25
class EnvVarGuard final
3582
26
{
3583
27
public:
3584
28
    // Set environment variable 'name' to 'val'.
3585
29
    // To clear the variable, pass nullptr for 'val'.
3586
30
    // The destructor restores the original setting.
3587
31
    EnvVarGuard(char const* name, char const* val)
3588
32
        : name_(name)
3589
33
    {
3590
34
        assert(name && *name != '\0');
3591
35
        auto const old_val = getenv(name);
3592
36
        if ((was_set_ = old_val != nullptr))
3593
37
        {
3594
38
            old_value_ = old_val;
3595
39
        }
3596
40
        if (val)
3597
41
        {
3598
42
            setenv(name, val, true);
3599
43
        }
3600
44
        else
3601
45
        {
3602
46
            unsetenv(name);
3603
47
        }
3604
48
    }
3605
49
3606
50
    // Restore the original setting.
3607
51
    ~EnvVarGuard()
3608
52
    {
3609
53
        if (was_set_)
3610
54
        {
3611
55
            setenv(name_.c_str(), old_value_.c_str(), true);
3612
56
        }
3613
57
        else
3614
58
        {
3615
59
            unsetenv(name_.c_str());
3616
60
        }
3617
61
    }
3618
62
3619
63
    EnvVarGuard(const EnvVarGuard&) = delete;
3620
64
    EnvVarGuard& operator=(const EnvVarGuard&) = delete;
3621
65
3622
66
private:
3623
67
    std::string name_;
3624
68
    std::string old_value_;
3625
69
    bool was_set_;
3626
70
};
Status:	Merged
Approved by:	James Henstridge on 2017-03-17
Approved revision:	116
Merged at revision:	113
Proposed branch:	lp:~michihenning/storage-framework/local-provider
Merge into:	lp:storage-framework/devel
Diff against target:	3626 lines (+3397/-9) 23 files modified CMakeLists.txt (+4/-1) debian/control.in (+2/-1) debian/storage-framework-registry.install (+2/-0) include/unity/storage/internal/gobj_memory.h (+212/-0) include/unity/storage/provider/Exceptions.h (+1/-1) src/CMakeLists.txt (+1/-0) src/local-provider/CMakeLists.txt (+43/-0) src/local-provider/LocalDownloadJob.cpp (+179/-0) src/local-provider/LocalDownloadJob.h (+54/-0) src/local-provider/LocalProvider.cpp (+586/-0) src/local-provider/LocalProvider.h (+84/-0) src/local-provider/LocalUploadJob.cpp (+338/-0) src/local-provider/LocalUploadJob.h (+79/-0) src/local-provider/com.canonical.StorageFramework.Provider.Local.service.in (+3/-0) src/local-provider/main.cpp (+52/-0) src/local-provider/utils.cpp (+146/-0) src/local-provider/utils.h (+45/-0) src/qt/internal/RuntimeImpl.cpp (+4/-0) src/qt/internal/StorageErrorImpl.cpp (+0/-6) tests/CMakeLists.txt (+1/-0) tests/local-provider/CMakeLists.txt (+18/-0) tests/local-provider/local-provider_test.cpp (+1473/-0) tests/utils/env_var_guard.h (+70/-0)
To merge this branch:	bzr merge lp:~michihenning/storage-framework/local-provider
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
James Henstridge		2017-03-14	Approve on 2017-03-17
unity-api-1-bot	continuous-integration		Approve on 2017-03-17
Review via email: mp+319773@code.launchpad.net