]>
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 | * Ceph - scalable distributed file system | |
5 | * | |
6 | * Copyright (C) 2015 Red Hat, Inc. | |
7 | * | |
8 | * This is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU Lesser General Public | |
10 | * License version 2.1, as published by the Free Software | |
11 | * Foundation. See file COPYING. | |
12 | * | |
13 | */ | |
14 | ||
15 | #include <stdint.h> | |
16 | #include <tuple> | |
17 | #include <iostream> | |
18 | #include <vector> | |
19 | #include <map> | |
20 | #include <random> | |
21 | #include "xxhash.h" | |
22 | ||
23 | #include "include/rados/librgw.h" | |
24 | #include "include/rados/rgw_file.h" | |
25 | ||
26 | #include "gtest/gtest.h" | |
27 | #include "common/ceph_argparse.h" | |
28 | #include "common/debug.h" | |
7c673cae FG |
29 | |
30 | #define dout_context g_ceph_context | |
31 | #define dout_subsys ceph_subsys_rgw | |
32 | ||
20effc67 TL |
33 | using namespace std; |
34 | ||
7c673cae FG |
35 | namespace { |
36 | librgw_t rgw = nullptr; | |
37 | string uid("testuser"); | |
38 | string access_key(""); | |
39 | string secret_key(""); | |
40 | struct rgw_fs *fs = nullptr; | |
41 | ||
42 | bool do_pre_list = false; | |
43 | bool do_put = false; | |
44 | bool do_bulk = false; | |
45 | bool do_writev = false; | |
46 | bool do_readv = false; | |
47 | bool do_verify = false; | |
48 | bool do_get = false; | |
f67539c2 | 49 | bool do_create = false; |
7c673cae FG |
50 | bool do_delete = false; |
51 | bool do_stat = false; // stat objects (not buckets) | |
52 | bool do_hexdump = false; | |
53 | ||
54 | bool object_open = false; | |
55 | ||
f67539c2 TL |
56 | uint32_t owner_uid = 867; |
57 | uint32_t owner_gid = 5309; | |
58 | uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE; | |
59 | ||
60 | string bucket_name = "blastoff"; | |
7c673cae FG |
61 | string object_name = "jocaml"; |
62 | ||
63 | struct rgw_file_handle *bucket_fh = nullptr; | |
64 | struct rgw_file_handle *object_fh = nullptr; | |
65 | ||
66 | typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type; | |
67 | std::vector<fid_type> fids; | |
68 | ||
69 | std::uniform_int_distribution<uint8_t> uint_dist; | |
70 | std::mt19937 rng; | |
71 | ||
72 | constexpr int iovcnt = 16; | |
73 | constexpr int page_size = 65536; | |
74 | constexpr int seed = 8675309; | |
75 | ||
76 | struct ZPage | |
77 | { | |
78 | char data[page_size]; | |
79 | uint64_t cksum; | |
80 | }; /* ZPage */ | |
81 | ||
82 | struct ZPageSet | |
83 | { | |
84 | std::vector<ZPage*> pages; | |
85 | struct iovec* iovs; | |
86 | ||
11fdf7f2 | 87 | explicit ZPageSet(int n) { |
7c673cae FG |
88 | pages.reserve(n); |
89 | iovs = (struct iovec*) calloc(n, sizeof(struct iovec)); | |
90 | for (int page_ix = 0; page_ix < n; ++page_ix) { | |
91 | ZPage* p = new ZPage(); | |
92 | for (int data_ix = 0; data_ix < page_size; ++data_ix) { | |
93 | p->data[data_ix] = uint_dist(rng); | |
94 | } // data_ix | |
95 | p->cksum = XXH64(p->data, page_size, seed); | |
96 | pages.emplace_back(p); | |
97 | // and iovs | |
98 | struct iovec* iov = &iovs[page_ix]; | |
99 | iov->iov_base = p->data; | |
100 | iov->iov_len = page_size; | |
101 | } // page_ix | |
102 | } | |
103 | ||
104 | int size() { return pages.size(); } | |
105 | ||
106 | struct iovec* get_iovs() { return iovs; } | |
107 | ||
108 | bool operator==(const ZPageSet& rhs) { | |
109 | int n = size(); | |
110 | for (int page_ix = 0; page_ix < n; ++page_ix) { | |
111 | ZPage* p1 = pages[page_ix]; | |
112 | ZPage* p2 = rhs.pages[page_ix]; | |
113 | if (p1->cksum != p2->cksum) | |
114 | return false; | |
115 | } | |
116 | return true; | |
117 | } | |
118 | ||
119 | bool operator==(const rgw_uio* uio) { | |
120 | uint64_t cksum; | |
121 | int vix = 0, off = 0; | |
122 | rgw_vio* vio = &uio->uio_vio[vix]; | |
123 | int vio_len = vio->vio_len; | |
124 | char *data; | |
125 | ||
126 | for (int ix = 0; ix < iovcnt; ++ix) { | |
127 | ZPage* p1 = pages[ix]; | |
128 | data = static_cast<char*>(vio->vio_base) + off; | |
129 | cksum = XXH64(data, page_size, seed); | |
130 | ||
131 | if (p1->cksum != cksum) { | |
132 | int r = memcmp(data, p1->data, page_size); | |
133 | std::cout << "problem at ix " << ix << " r " << r<< std::endl; | |
134 | return false; | |
135 | } | |
136 | ||
137 | off += page_size; | |
138 | if (off >= vio_len) { | |
139 | vio = &uio->uio_vio[++vix]; | |
140 | vio_len = vio->vio_len; | |
141 | off = 0; | |
142 | } | |
143 | } | |
144 | return true; | |
145 | } | |
146 | ||
147 | void cksum() { | |
148 | int n = size(); | |
149 | for (int page_ix = 0; page_ix < n; ++page_ix) { | |
150 | ZPage* p = pages[page_ix]; | |
151 | p->cksum = XXH64(p->data, page_size, seed); | |
152 | } | |
153 | } | |
154 | ||
155 | void reset_iovs() { // VOP_READ and VOP_WRITE update | |
156 | int n = size(); | |
157 | for (int page_ix = 0; page_ix < n; ++page_ix) { | |
158 | ZPage* p = pages[page_ix]; | |
159 | struct iovec* iov = &iovs[page_ix]; | |
160 | iov->iov_base = p->data; | |
161 | iov->iov_len = page_size; | |
162 | } | |
163 | } | |
164 | ||
165 | ~ZPageSet() { | |
166 | for (unsigned int ix = 0; ix < pages.size(); ++ix) | |
167 | delete pages[ix]; | |
168 | free(iovs); | |
169 | } | |
170 | }; /* ZPageSet */ | |
171 | ||
172 | rgw_uio uio[1]; | |
173 | ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages | |
174 | ||
175 | struct { | |
176 | int argc; | |
177 | char **argv; | |
178 | } saved_args; | |
179 | } | |
180 | ||
181 | TEST(LibRGW, INIT) { | |
182 | int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv); | |
183 | ASSERT_EQ(ret, 0); | |
184 | ASSERT_NE(rgw, nullptr); | |
185 | } | |
186 | ||
187 | TEST(LibRGW, MOUNT) { | |
3efd9988 FG |
188 | int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(), |
189 | "/", &fs, RGW_MOUNT_FLAG_NONE); | |
7c673cae FG |
190 | ASSERT_EQ(ret, 0); |
191 | ASSERT_NE(fs, nullptr); | |
192 | } | |
193 | ||
f67539c2 TL |
194 | TEST(LibRGW, CREATE_BUCKET) { |
195 | if (do_create) { | |
196 | struct stat st; | |
197 | struct rgw_file_handle *fh; | |
198 | ||
199 | st.st_uid = owner_uid; | |
200 | st.st_gid = owner_gid; | |
201 | st.st_mode = 755; | |
202 | ||
203 | int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask, | |
204 | &fh, RGW_MKDIR_FLAG_NONE); | |
205 | ASSERT_EQ(ret, 0); | |
206 | } | |
207 | } | |
208 | ||
7c673cae FG |
209 | TEST(LibRGW, LOOKUP_BUCKET) { |
210 | int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh, | |
eafe8130 | 211 | nullptr, 0, RGW_LOOKUP_FLAG_NONE); |
7c673cae FG |
212 | ASSERT_EQ(ret, 0); |
213 | } | |
214 | ||
215 | extern "C" { | |
216 | static bool r2_cb(const char* name, void *arg, uint64_t offset, | |
eafe8130 | 217 | struct stat *st, uint32_t st_mask, |
7c673cae FG |
218 | uint32_t flags) { |
219 | // don't need arg--it would point to fids | |
220 | fids.push_back(fid_type(name, offset, nullptr)); | |
221 | return true; /* XXX ? */ | |
222 | } | |
223 | } | |
224 | ||
225 | TEST(LibRGW, LIST_OBJECTS) { | |
226 | if (do_pre_list) { | |
227 | /* list objects via readdir, bucketwise */ | |
228 | using std::get; | |
229 | ||
230 | ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " | |
231 | << bucket_name << dendl; | |
232 | bool eof = false; | |
233 | uint64_t offset = 0; | |
234 | int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids, | |
235 | &eof, RGW_READDIR_FLAG_NONE); | |
236 | for (auto& fid : fids) { | |
237 | std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid) | |
238 | << std::endl; | |
239 | } | |
240 | ASSERT_EQ(ret, 0); | |
241 | } | |
242 | } | |
243 | ||
244 | TEST(LibRGW, LOOKUP_OBJECT) { | |
245 | if (do_get || do_stat || do_put || do_bulk || do_readv || do_writev) { | |
246 | int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh, | |
eafe8130 | 247 | nullptr, 0, RGW_LOOKUP_FLAG_CREATE); |
7c673cae FG |
248 | ASSERT_EQ(ret, 0); |
249 | } | |
250 | } | |
251 | ||
252 | TEST(LibRGW, OBJ_OPEN) { | |
253 | if (do_get || do_put || do_readv || do_writev) { | |
254 | int ret = rgw_open(fs, object_fh, 0 /* posix flags */, 0 /* flags */); | |
255 | ASSERT_EQ(ret, 0); | |
256 | object_open = true; | |
257 | } | |
258 | } | |
259 | ||
260 | TEST(LibRGW, PUT_OBJECT) { | |
261 | if (do_put) { | |
262 | size_t nbytes; | |
263 | string data = "hi mom"; // fix this | |
264 | int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes, | |
265 | (void*) data.c_str(), RGW_WRITE_FLAG_NONE); | |
266 | ASSERT_EQ(ret, 0); | |
267 | ASSERT_EQ(nbytes, data.length()); | |
f67539c2 TL |
268 | /* commit write transaction */ |
269 | ret = rgw_close(fs, object_fh, 0 /* flags */); | |
270 | ASSERT_EQ(ret, 0); | |
7c673cae FG |
271 | } |
272 | } | |
273 | ||
274 | TEST(LibRGW, GET_OBJECT) { | |
275 | if (do_get) { | |
276 | char sbuf[512]; | |
277 | memset(sbuf, 0, 512); | |
278 | size_t nread; | |
279 | int ret = rgw_read(fs, object_fh, 0 /* off */, 512 /* len */, &nread, sbuf, | |
280 | RGW_READ_FLAG_NONE); | |
281 | ASSERT_EQ(ret, 0); | |
282 | buffer::list bl; | |
283 | bl.push_back(buffer::create_static(nread, sbuf)); | |
284 | if (do_hexdump) { | |
285 | dout(15) << ""; | |
286 | bl.hexdump(*_dout); | |
287 | *_dout << dendl; | |
288 | } | |
289 | } | |
290 | } | |
291 | ||
292 | TEST(LibRGW, STAT_OBJECT) { | |
293 | if (do_stat) { | |
294 | struct stat st; | |
295 | int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE); | |
296 | ASSERT_EQ(ret, 0); | |
297 | dout(15) << "rgw_getattr on " << object_name << " size = " | |
298 | << st.st_size << dendl; | |
299 | } | |
300 | } | |
301 | ||
302 | TEST(LibRGW, WRITE_READ_VERIFY) | |
303 | { | |
304 | if (do_bulk && do_put) { | |
305 | ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages | |
306 | struct iovec *iovs = zp_set1.get_iovs(); | |
307 | ||
308 | /* read after write POSIX-style */ | |
309 | size_t nbytes, off = 0; | |
310 | for (int ix = 0; ix < 16; ++ix, off += page_size) { | |
311 | struct iovec *iov = &iovs[ix]; | |
312 | int ret = rgw_write(fs, object_fh, off, page_size, &nbytes, | |
313 | iov->iov_base, RGW_WRITE_FLAG_NONE); | |
314 | ASSERT_EQ(ret, 0); | |
315 | ASSERT_EQ(nbytes, size_t(page_size)); | |
316 | } | |
317 | zp_set1.reset_iovs(); | |
318 | } | |
319 | } | |
320 | ||
321 | /* "functions that call alloca are not inlined" | |
322 | * --alexandre oliva | |
323 | * http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html | |
324 | */ | |
325 | #define alloca_uio() \ | |
326 | do {\ | |
327 | int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio); \ | |
328 | uio = static_cast<rgw_uio*>(alloca(uiosz)); \ | |
329 | memset(uio, 0, uiosz); \ | |
330 | uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio)); \ | |
331 | } while (0); \ | |
332 | ||
333 | TEST(LibRGW, WRITEV) | |
334 | { | |
335 | if (do_writev) { | |
336 | rgw_uio* uio; | |
337 | struct iovec *iovs = zp_set1.get_iovs(); | |
338 | alloca_uio(); | |
339 | ASSERT_NE(uio, nullptr); | |
340 | ||
341 | for (int ix = 0; ix < iovcnt; ++ix) { | |
342 | struct iovec *iov = &iovs[ix]; | |
343 | rgw_vio *vio = &(uio->uio_vio[ix]); | |
344 | vio->vio_base = iov->iov_base; | |
345 | vio->vio_len = iov->iov_len; | |
346 | vio->vio_u1 = iov; // private data | |
347 | } | |
348 | uio->uio_cnt = iovcnt; | |
349 | uio->uio_offset = iovcnt * page_size; | |
350 | ||
351 | int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE); | |
352 | ASSERT_EQ(ret, 0); | |
353 | } | |
354 | } | |
355 | ||
356 | TEST(LibRGW, READV) | |
357 | { | |
358 | if (do_readv) { | |
359 | memset(uio, 0, sizeof(rgw_uio)); | |
360 | uio->uio_offset = 0; // ok, it was already 0 | |
361 | uio->uio_resid = UINT64_MAX; | |
362 | int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE); | |
363 | ASSERT_EQ(ret, 0); | |
364 | buffer::list bl; | |
365 | for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) { | |
366 | rgw_vio *vio = &(uio->uio_vio[ix]); | |
367 | bl.push_back( | |
368 | buffer::create_static(vio->vio_len, | |
369 | static_cast<char*>(vio->vio_base))); | |
370 | } | |
371 | ||
372 | /* length check */ | |
373 | ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size}); | |
374 | ||
375 | if (do_hexdump) { | |
376 | dout(15) << ""; | |
377 | bl.hexdump(*_dout); | |
378 | *_dout << dendl; | |
379 | } | |
380 | } | |
381 | } | |
382 | ||
383 | TEST(LibRGW, READV_AFTER_WRITEV) | |
384 | { | |
385 | /* checksum data */ | |
386 | if (do_readv && do_writev && do_verify) { | |
387 | ASSERT_TRUE(zp_set1 == uio); | |
388 | } | |
389 | } | |
390 | ||
391 | TEST(LibRGW, DELETE_OBJECT) { | |
392 | if (do_delete) { | |
393 | int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(), | |
394 | RGW_UNLINK_FLAG_NONE); | |
395 | ASSERT_EQ(ret, 0); | |
396 | } | |
397 | } | |
398 | ||
f67539c2 TL |
399 | TEST(LibRGW, DELETE_BUCKET) { |
400 | if (do_delete) { | |
401 | int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(), | |
402 | RGW_UNLINK_FLAG_NONE); | |
403 | ASSERT_EQ(ret, 0); | |
404 | } | |
405 | } | |
406 | ||
7c673cae FG |
407 | TEST(LibRGW, CLEANUP) { |
408 | if (do_readv) { | |
409 | // release resources | |
410 | ASSERT_NE(uio->uio_rele, nullptr); | |
411 | if (uio->uio_rele) { | |
412 | uio->uio_rele(uio, RGW_UIO_NONE); | |
413 | } | |
414 | } | |
415 | int ret; | |
416 | if (object_open) { | |
417 | ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE); | |
418 | ASSERT_EQ(ret, 0); | |
419 | } | |
420 | if (object_fh) { | |
421 | ret = rgw_fh_rele(fs, object_fh, 0 /* flags */); | |
422 | ASSERT_EQ(ret, 0); | |
423 | } | |
424 | ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */); | |
425 | ASSERT_EQ(ret, 0); | |
426 | } | |
427 | ||
428 | TEST(LibRGW, UMOUNT) { | |
429 | if (! fs) | |
430 | return; | |
431 | ||
432 | int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE); | |
433 | ASSERT_EQ(ret, 0); | |
434 | } | |
435 | ||
436 | TEST(LibRGW, SHUTDOWN) { | |
437 | librgw_shutdown(rgw); | |
438 | } | |
439 | ||
440 | int main(int argc, char *argv[]) | |
441 | { | |
20effc67 | 442 | auto args = argv_to_vec(argc, argv); |
7c673cae FG |
443 | env_to_vec(args); |
444 | ||
20effc67 | 445 | char* v = getenv("AWS_ACCESS_KEY_ID"); |
7c673cae FG |
446 | if (v) { |
447 | access_key = v; | |
448 | } | |
449 | ||
450 | v = getenv("AWS_SECRET_ACCESS_KEY"); | |
451 | if (v) { | |
452 | secret_key = v; | |
453 | } | |
454 | ||
20effc67 | 455 | string val; |
7c673cae FG |
456 | for (auto arg_iter = args.begin(); arg_iter != args.end();) { |
457 | if (ceph_argparse_witharg(args, arg_iter, &val, "--access", | |
458 | (char*) nullptr)) { | |
459 | access_key = val; | |
460 | } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret", | |
461 | (char*) nullptr)) { | |
462 | secret_key = val; | |
463 | } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid", | |
464 | (char*) nullptr)) { | |
465 | uid = val; | |
466 | } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn", | |
467 | (char*) nullptr)) { | |
468 | bucket_name = val; | |
469 | } else if (ceph_argparse_flag(args, arg_iter, "--get", | |
470 | (char*) nullptr)) { | |
471 | do_get = true; | |
472 | } else if (ceph_argparse_flag(args, arg_iter, "--stat", | |
473 | (char*) nullptr)) { | |
474 | do_stat = true; | |
475 | } else if (ceph_argparse_flag(args, arg_iter, "--put", | |
476 | (char*) nullptr)) { | |
477 | do_put = true; | |
478 | } else if (ceph_argparse_flag(args, arg_iter, "--bulk", | |
479 | (char*) nullptr)) { | |
480 | do_bulk = true; | |
481 | } else if (ceph_argparse_flag(args, arg_iter, "--writev", | |
482 | (char*) nullptr)) { | |
483 | do_writev = true; | |
484 | } else if (ceph_argparse_flag(args, arg_iter, "--readv", | |
485 | (char*) nullptr)) { | |
486 | do_readv = true; | |
487 | } else if (ceph_argparse_flag(args, arg_iter, "--verify", | |
488 | (char*) nullptr)) { | |
489 | do_verify = true; | |
490 | } else if (ceph_argparse_flag(args, arg_iter, "--delete", | |
491 | (char*) nullptr)) { | |
492 | do_delete = true; | |
493 | } else if (ceph_argparse_flag(args, arg_iter, "--prelist", | |
494 | (char*) nullptr)) { | |
495 | do_pre_list = true; | |
f67539c2 TL |
496 | } else if (ceph_argparse_flag(args, arg_iter, "--create", |
497 | (char*) nullptr)) { | |
498 | do_create = true; | |
7c673cae FG |
499 | } else if (ceph_argparse_flag(args, arg_iter, "--hexdump", |
500 | (char*) nullptr)) { | |
501 | do_hexdump = true; | |
502 | } else { | |
503 | ++arg_iter; | |
504 | } | |
505 | } | |
506 | ||
11fdf7f2 | 507 | /* don't accidentally run as anonymous */ |
7c673cae FG |
508 | if ((access_key == "") || |
509 | (secret_key == "")) { | |
510 | std::cout << argv[0] << " no AWS credentials, exiting" << std::endl; | |
511 | return EPERM; | |
512 | } | |
513 | ||
514 | saved_args.argc = argc; | |
515 | saved_args.argv = argv; | |
516 | ||
517 | ::testing::InitGoogleTest(&argc, argv); | |
518 | return RUN_ALL_TESTS(); | |
519 | } |