]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | ||
4 | #include "test/librbd/test_mock_fixture.h" | |
5 | #include "test/librbd/test_support.h" | |
6 | #include "test/librbd/mock/MockImageCtx.h" | |
7 | #include "test/librados_test_stub/MockTestMemIoCtxImpl.h" | |
8 | #include "include/stringify.h" | |
9 | #include "common/bit_vector.hpp" | |
10 | #include "librbd/ImageState.h" | |
11 | #include "librbd/internal.h" | |
12 | #include "librbd/operation/SnapshotRollbackRequest.h" | |
13 | #include "gmock/gmock.h" | |
14 | #include "gtest/gtest.h" | |
15 | ||
16 | namespace librbd { | |
17 | ||
18 | namespace { | |
19 | ||
20 | struct MockOperationImageCtx : public MockImageCtx { | |
21 | MockOperationImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { | |
22 | } | |
23 | }; | |
24 | ||
25 | } // anonymous namespace | |
26 | ||
27 | namespace operation { | |
28 | ||
29 | template <> | |
30 | struct ResizeRequest<MockOperationImageCtx> { | |
31 | static ResizeRequest *s_instance; | |
32 | Context *on_finish = nullptr; | |
33 | ||
34 | static ResizeRequest* create(MockOperationImageCtx &image_ctx, Context *on_finish, | |
35 | uint64_t new_size, bool allow_shrink, | |
36 | ProgressContext &prog_ctx, uint64_t journal_op_tid, | |
37 | bool disable_journal) { | |
38 | assert(s_instance != nullptr); | |
39 | assert(journal_op_tid == 0); | |
40 | assert(disable_journal); | |
41 | s_instance->on_finish = on_finish; | |
42 | return s_instance; | |
43 | } | |
44 | ||
45 | ResizeRequest() { | |
46 | s_instance = this; | |
47 | } | |
48 | ||
49 | MOCK_METHOD0(send, void()); | |
50 | }; | |
51 | ||
52 | ResizeRequest<MockOperationImageCtx> *ResizeRequest<MockOperationImageCtx>::s_instance = nullptr; | |
53 | ||
54 | } // namespace operation | |
55 | ||
56 | template <> | |
57 | struct AsyncRequest<MockOperationImageCtx> : public AsyncRequest<MockImageCtx> { | |
58 | MockOperationImageCtx &m_image_ctx; | |
59 | ||
60 | AsyncRequest(MockOperationImageCtx &image_ctx, Context *on_finish) | |
61 | : AsyncRequest<MockImageCtx>(image_ctx, on_finish), m_image_ctx(image_ctx) { | |
62 | } | |
63 | }; | |
64 | ||
65 | } // namespace librbd | |
66 | ||
67 | // template definitions | |
68 | #include "librbd/AsyncRequest.cc" | |
69 | #include "librbd/AsyncObjectThrottle.cc" | |
70 | #include "librbd/operation/Request.cc" | |
71 | #include "librbd/operation/SnapshotRollbackRequest.cc" | |
72 | ||
73 | namespace librbd { | |
74 | namespace operation { | |
75 | ||
76 | using ::testing::_; | |
77 | using ::testing::InSequence; | |
78 | using ::testing::Return; | |
79 | using ::testing::WithArg; | |
80 | ||
81 | class TestMockOperationSnapshotRollbackRequest : public TestMockFixture { | |
82 | public: | |
83 | typedef SnapshotRollbackRequest<MockOperationImageCtx> MockSnapshotRollbackRequest; | |
84 | typedef ResizeRequest<MockOperationImageCtx> MockResizeRequest; | |
85 | ||
86 | void expect_block_writes(MockOperationImageCtx &mock_image_ctx, int r) { | |
87 | EXPECT_CALL(*mock_image_ctx.io_work_queue, block_writes(_)) | |
88 | .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); | |
89 | } | |
90 | ||
91 | void expect_unblock_writes(MockOperationImageCtx &mock_image_ctx) { | |
92 | EXPECT_CALL(*mock_image_ctx.io_work_queue, unblock_writes()) | |
93 | .Times(1); | |
94 | } | |
95 | ||
96 | void expect_get_image_size(MockOperationImageCtx &mock_image_ctx, | |
97 | uint64_t size) { | |
98 | EXPECT_CALL(mock_image_ctx, get_image_size(CEPH_NOSNAP)) | |
99 | .WillOnce(Return(size)); | |
100 | } | |
101 | ||
102 | void expect_resize(MockOperationImageCtx &mock_image_ctx, | |
103 | MockResizeRequest &mock_resize_request, int r) { | |
104 | expect_get_image_size(mock_image_ctx, 123); | |
105 | EXPECT_CALL(mock_resize_request, send()) | |
106 | .WillOnce(FinishRequest(&mock_resize_request, r, | |
107 | &mock_image_ctx)); | |
108 | } | |
109 | ||
110 | void expect_rollback_object_map(MockOperationImageCtx &mock_image_ctx, | |
111 | MockObjectMap &mock_object_map) { | |
112 | if (mock_image_ctx.object_map != nullptr) { | |
113 | EXPECT_CALL(mock_object_map, rollback(_, _)) | |
114 | .WillOnce(WithArg<1>(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue))); | |
115 | } | |
116 | } | |
117 | ||
118 | void expect_get_object_name(MockOperationImageCtx &mock_image_ctx, | |
119 | uint64_t object_num) { | |
120 | EXPECT_CALL(mock_image_ctx, get_object_name(object_num)) | |
121 | .WillOnce(Return("object-name-" + stringify(object_num))); | |
122 | } | |
123 | ||
124 | void expect_get_current_size(MockOperationImageCtx &mock_image_ctx, uint64_t size) { | |
125 | EXPECT_CALL(mock_image_ctx, get_current_size()) | |
126 | .WillOnce(Return(size)); | |
127 | } | |
128 | ||
129 | void expect_rollback_snap_id(MockOperationImageCtx &mock_image_ctx, | |
130 | const std::string &oid, int r) { | |
131 | EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.data_ctx), | |
132 | selfmanaged_snap_rollback(oid, _)) | |
133 | .WillOnce(Return(r)); | |
134 | } | |
135 | ||
136 | void expect_rollback(MockOperationImageCtx &mock_image_ctx, int r) { | |
137 | expect_get_current_size(mock_image_ctx, 1); | |
138 | expect_get_object_name(mock_image_ctx, 0); | |
139 | expect_rollback_snap_id(mock_image_ctx, "object-name-0", r); | |
140 | } | |
141 | ||
142 | void expect_create_object_map(MockOperationImageCtx &mock_image_ctx, | |
143 | MockObjectMap *mock_object_map) { | |
144 | EXPECT_CALL(mock_image_ctx, create_object_map(_)) | |
145 | .WillOnce(Return(mock_object_map)); | |
146 | } | |
147 | ||
148 | void expect_open_object_map(MockOperationImageCtx &mock_image_ctx, | |
149 | MockObjectMap &mock_object_map) { | |
150 | EXPECT_CALL(mock_object_map, open(_)) | |
151 | .WillOnce(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue)); | |
152 | } | |
153 | ||
154 | void expect_refresh_object_map(MockOperationImageCtx &mock_image_ctx, | |
155 | MockObjectMap &mock_object_map) { | |
156 | if (mock_image_ctx.object_map != nullptr) { | |
157 | expect_create_object_map(mock_image_ctx, &mock_object_map); | |
158 | expect_open_object_map(mock_image_ctx, mock_object_map); | |
159 | } | |
160 | } | |
161 | ||
162 | void expect_invalidate_cache(MockOperationImageCtx &mock_image_ctx, int r) { | |
163 | if (mock_image_ctx.object_cacher != nullptr) { | |
164 | EXPECT_CALL(mock_image_ctx, invalidate_cache(true, _)) | |
165 | .WillOnce(WithArg<1>(CompleteContext(r, static_cast<ContextWQ*>(NULL)))); | |
166 | } | |
167 | } | |
168 | ||
169 | int when_snap_rollback(MockOperationImageCtx &mock_image_ctx, | |
170 | const std::string &snap_name, | |
171 | uint64_t snap_id, uint64_t snap_size) { | |
172 | C_SaferCond cond_ctx; | |
173 | librbd::NoOpProgressContext prog_ctx; | |
174 | MockSnapshotRollbackRequest *req = new MockSnapshotRollbackRequest( | |
175 | mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), snap_name, | |
176 | snap_id, snap_size, prog_ctx); | |
177 | { | |
178 | RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); | |
179 | req->send(); | |
180 | } | |
181 | return cond_ctx.wait(); | |
182 | } | |
183 | }; | |
184 | ||
185 | TEST_F(TestMockOperationSnapshotRollbackRequest, Success) { | |
186 | librbd::ImageCtx *ictx; | |
187 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
188 | ||
189 | MockOperationImageCtx mock_image_ctx(*ictx); | |
190 | MockExclusiveLock mock_exclusive_lock; | |
191 | MockJournal mock_journal; | |
192 | MockObjectMap *mock_object_map = new MockObjectMap(); | |
193 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
194 | *mock_object_map); | |
195 | expect_op_work_queue(mock_image_ctx); | |
196 | ||
197 | InSequence seq; | |
198 | MockResizeRequest mock_resize_request; | |
199 | expect_append_op_event(mock_image_ctx, false, 0); | |
200 | expect_block_writes(mock_image_ctx, 0); | |
201 | expect_resize(mock_image_ctx, mock_resize_request, 0); | |
202 | expect_rollback_object_map(mock_image_ctx, *mock_object_map); | |
203 | expect_rollback(mock_image_ctx, 0); | |
204 | expect_refresh_object_map(mock_image_ctx, *mock_object_map); | |
205 | expect_invalidate_cache(mock_image_ctx, 0); | |
206 | expect_commit_op_event(mock_image_ctx, 0); | |
207 | expect_unblock_writes(mock_image_ctx); | |
208 | ASSERT_EQ(0, when_snap_rollback(mock_image_ctx, "snap", 123, 0)); | |
209 | } | |
210 | ||
211 | TEST_F(TestMockOperationSnapshotRollbackRequest, BlockWritesError) { | |
212 | librbd::ImageCtx *ictx; | |
213 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
214 | ||
215 | MockOperationImageCtx mock_image_ctx(*ictx); | |
216 | MockExclusiveLock mock_exclusive_lock; | |
217 | MockJournal mock_journal; | |
218 | MockObjectMap mock_object_map; | |
219 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
220 | mock_object_map); | |
221 | expect_op_work_queue(mock_image_ctx); | |
222 | ||
223 | InSequence seq; | |
224 | expect_append_op_event(mock_image_ctx, false, 0); | |
225 | expect_block_writes(mock_image_ctx, -EINVAL); | |
226 | expect_commit_op_event(mock_image_ctx, -EINVAL); | |
227 | expect_unblock_writes(mock_image_ctx); | |
228 | ASSERT_EQ(-EINVAL, when_snap_rollback(mock_image_ctx, "snap", 123, 0)); | |
229 | } | |
230 | ||
231 | TEST_F(TestMockOperationSnapshotRollbackRequest, SkipResize) { | |
232 | librbd::ImageCtx *ictx; | |
233 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
234 | ||
235 | MockOperationImageCtx mock_image_ctx(*ictx); | |
236 | MockExclusiveLock mock_exclusive_lock; | |
237 | MockJournal mock_journal; | |
238 | MockObjectMap *mock_object_map = new MockObjectMap(); | |
239 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
240 | *mock_object_map); | |
241 | expect_op_work_queue(mock_image_ctx); | |
242 | ||
243 | InSequence seq; | |
244 | expect_append_op_event(mock_image_ctx, false, 0); | |
245 | expect_block_writes(mock_image_ctx, 0); | |
246 | expect_get_image_size(mock_image_ctx, 345); | |
247 | expect_rollback_object_map(mock_image_ctx, *mock_object_map); | |
248 | expect_rollback(mock_image_ctx, 0); | |
249 | expect_refresh_object_map(mock_image_ctx, *mock_object_map); | |
250 | expect_invalidate_cache(mock_image_ctx, 0); | |
251 | expect_commit_op_event(mock_image_ctx, 0); | |
252 | expect_unblock_writes(mock_image_ctx); | |
253 | ASSERT_EQ(0, when_snap_rollback(mock_image_ctx, "snap", 123, 345)); | |
254 | } | |
255 | ||
256 | TEST_F(TestMockOperationSnapshotRollbackRequest, ResizeError) { | |
257 | librbd::ImageCtx *ictx; | |
258 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
259 | ||
260 | MockOperationImageCtx mock_image_ctx(*ictx); | |
261 | MockExclusiveLock mock_exclusive_lock; | |
262 | MockJournal mock_journal; | |
263 | MockObjectMap mock_object_map; | |
264 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
265 | mock_object_map); | |
266 | expect_op_work_queue(mock_image_ctx); | |
267 | ||
268 | InSequence seq; | |
269 | MockResizeRequest mock_resize_request; | |
270 | expect_append_op_event(mock_image_ctx, false, 0); | |
271 | expect_block_writes(mock_image_ctx, 0); | |
272 | expect_resize(mock_image_ctx, mock_resize_request, -EINVAL); | |
273 | expect_commit_op_event(mock_image_ctx, -EINVAL); | |
274 | expect_unblock_writes(mock_image_ctx); | |
275 | ASSERT_EQ(-EINVAL, when_snap_rollback(mock_image_ctx, "snap", 123, 0)); | |
276 | } | |
277 | ||
278 | TEST_F(TestMockOperationSnapshotRollbackRequest, RollbackObjectsError) { | |
279 | librbd::ImageCtx *ictx; | |
280 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
281 | ||
282 | MockOperationImageCtx mock_image_ctx(*ictx); | |
283 | MockExclusiveLock mock_exclusive_lock; | |
284 | MockJournal mock_journal; | |
285 | MockObjectMap mock_object_map; | |
286 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
287 | mock_object_map); | |
288 | expect_op_work_queue(mock_image_ctx); | |
289 | ||
290 | InSequence seq; | |
291 | MockResizeRequest mock_resize_request; | |
292 | expect_append_op_event(mock_image_ctx, false, 0); | |
293 | expect_block_writes(mock_image_ctx, 0); | |
294 | expect_resize(mock_image_ctx, mock_resize_request, 0); | |
295 | expect_rollback_object_map(mock_image_ctx, mock_object_map); | |
296 | expect_rollback(mock_image_ctx, -EINVAL); | |
297 | expect_commit_op_event(mock_image_ctx, -EINVAL); | |
298 | expect_unblock_writes(mock_image_ctx); | |
299 | ASSERT_EQ(-EINVAL, when_snap_rollback(mock_image_ctx, "snap", 123, 0)); | |
300 | } | |
301 | ||
302 | TEST_F(TestMockOperationSnapshotRollbackRequest, InvalidateCacheError) { | |
303 | librbd::ImageCtx *ictx; | |
304 | ASSERT_EQ(0, open_image(m_image_name, &ictx)); | |
305 | ||
306 | MockOperationImageCtx mock_image_ctx(*ictx); | |
307 | MockExclusiveLock mock_exclusive_lock; | |
308 | MockJournal mock_journal; | |
309 | MockObjectMap *mock_object_map = new MockObjectMap(); | |
310 | initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal, | |
311 | *mock_object_map); | |
312 | expect_op_work_queue(mock_image_ctx); | |
313 | ||
314 | InSequence seq; | |
315 | MockResizeRequest mock_resize_request; | |
316 | expect_append_op_event(mock_image_ctx, false, 0); | |
317 | expect_block_writes(mock_image_ctx, 0); | |
318 | expect_resize(mock_image_ctx, mock_resize_request, 0); | |
319 | expect_rollback_object_map(mock_image_ctx, *mock_object_map); | |
320 | expect_rollback(mock_image_ctx, 0); | |
321 | expect_refresh_object_map(mock_image_ctx, *mock_object_map); | |
322 | expect_invalidate_cache(mock_image_ctx, -EINVAL); | |
323 | expect_commit_op_event(mock_image_ctx, -EINVAL); | |
324 | expect_unblock_writes(mock_image_ctx); | |
325 | ASSERT_EQ(-EINVAL, when_snap_rollback(mock_image_ctx, "snap", 123, 0)); | |
326 | } | |
327 | ||
328 | } // namespace operation | |
329 | } // namespace librbd |