]>
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 | ||
19 | #include "include/rados/librgw.h" | |
20 | #include "include/rados/rgw_file.h" | |
21 | ||
22 | #include "gtest/gtest.h" | |
23 | #include "common/ceph_argparse.h" | |
24 | #include "common/debug.h" | |
25 | #include "global/global_init.h" | |
26 | ||
27 | #define dout_subsys ceph_subsys_rgw | |
28 | ||
20effc67 TL |
29 | using namespace std; |
30 | ||
7c673cae | 31 | namespace { |
1e59de90 | 32 | librgw_t h_rgw = nullptr; |
7c673cae FG |
33 | string uid("testuser"); |
34 | string access_key(""); | |
35 | string secret_key(""); | |
36 | struct rgw_fs *fs = nullptr; | |
37 | typedef std::tuple<string, uint64_t, struct rgw_file_handle*> fid_type; //in c++2014 can alias... | |
38 | typedef std::tuple<fid_type, std::vector<fid_type>> bucket_type; | |
39 | ||
40 | std::vector<fid_type> fids1; | |
41 | std::vector<bucket_type> bucket_matrix; | |
42 | ||
43 | bool do_getattr = false; | |
44 | ||
45 | struct { | |
46 | int argc; | |
47 | char **argv; | |
48 | } saved_args; | |
49 | } | |
50 | ||
51 | TEST(LibRGW, INIT) { | |
1e59de90 | 52 | int ret = librgw_create(&h_rgw, saved_args.argc, saved_args.argv); |
7c673cae | 53 | ASSERT_EQ(ret, 0); |
1e59de90 | 54 | ASSERT_NE(h_rgw, nullptr); |
7c673cae FG |
55 | } |
56 | ||
57 | TEST(LibRGW, MOUNT) { | |
1e59de90 | 58 | int ret = rgw_mount2(h_rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(), |
3efd9988 | 59 | "/", &fs, RGW_MOUNT_FLAG_NONE); |
7c673cae FG |
60 | ASSERT_EQ(ret, 0); |
61 | ASSERT_NE(fs, nullptr); | |
62 | } | |
63 | ||
64 | TEST(LibRGW, GETATTR_ROOT) { | |
65 | if (do_getattr) { | |
7c673cae FG |
66 | if (! fs) |
67 | return; | |
68 | ||
69 | struct stat st; | |
70 | int ret = rgw_getattr(fs, fs->root_fh, &st, RGW_GETATTR_FLAG_NONE); | |
71 | ASSERT_EQ(ret, 0); | |
72 | } | |
73 | } | |
74 | ||
75 | extern "C" { | |
1e59de90 | 76 | static int r1_cb(const char* name, void *arg, uint64_t offset, |
eafe8130 | 77 | struct stat* st, uint32_t st_mask, |
7c673cae FG |
78 | uint32_t flags) { |
79 | // don't need arg--it would point to fids1 | |
80 | fids1.push_back(fid_type(name, offset, nullptr /* handle */)); | |
81 | return true; /* XXX ? */ | |
82 | } | |
83 | } | |
84 | ||
85 | TEST(LibRGW, LIST_BUCKETS) { | |
86 | /* list buckets via readdir in fs root */ | |
87 | using std::get; | |
88 | ||
89 | if (! fs) | |
90 | return; | |
91 | ||
92 | bool eof = false; | |
93 | uint64_t offset = 0; | |
94 | int ret = rgw_readdir(fs, fs->root_fh, &offset, r1_cb, &fids1, &eof, | |
95 | RGW_READDIR_FLAG_NONE); | |
96 | for (auto& fid : fids1) { | |
97 | std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid) | |
98 | << std::endl; | |
99 | /* push row for bucket into bucket_matrix */ | |
100 | bucket_matrix.push_back(bucket_type(fid, std::vector<fid_type>())); | |
101 | } | |
102 | ASSERT_EQ(ret, 0); | |
103 | } | |
104 | ||
105 | TEST(LibRGW, LOOKUP_BUCKETS) { | |
106 | using std::get; | |
107 | ||
108 | if (! fs) | |
109 | return; | |
110 | ||
111 | for (auto& fid_row : bucket_matrix) { | |
112 | auto& fid = get<0>(fid_row); | |
113 | // auto& obj_vector = get<1>(fid_row); | |
114 | struct rgw_file_handle *rgw_fh = nullptr; | |
115 | ASSERT_EQ(0, rgw_lookup(fs, fs->root_fh, get<0>(fid).c_str(), &rgw_fh, | |
eafe8130 | 116 | nullptr /* stat */, 0 /* mask */, 0 /* flags */)); |
7c673cae FG |
117 | get<2>(fid) = rgw_fh; |
118 | ASSERT_NE(get<2>(fid), nullptr); | |
119 | } | |
120 | } | |
121 | ||
122 | TEST(LibRGW, GETATTR_BUCKETS) { | |
123 | if (do_getattr) { | |
124 | using std::get; | |
125 | ||
126 | if (! fs) | |
127 | return; | |
128 | ||
129 | struct stat st; | |
130 | ||
131 | for (auto& fid_row : bucket_matrix) { | |
132 | auto& fid = get<0>(fid_row); | |
133 | struct rgw_file_handle *rgw_fh = get<2>(fid); | |
134 | ASSERT_EQ(0, rgw_getattr(fs, rgw_fh, &st, RGW_GETATTR_FLAG_NONE)); | |
135 | } | |
136 | } | |
137 | } | |
138 | ||
139 | extern "C" { | |
1e59de90 | 140 | static int r2_cb(const char* name, void *arg, uint64_t offset, |
eafe8130 | 141 | struct stat* st, uint32_t st_mask, |
7c673cae FG |
142 | uint32_t flags) { |
143 | std::vector<fid_type>& obj_vector = *(static_cast<std::vector<fid_type>*>(arg)); | |
144 | obj_vector.push_back(fid_type(name, offset, nullptr)); | |
145 | return true; /* XXX ? */ | |
146 | } | |
147 | } | |
148 | ||
149 | TEST(LibRGW, LIST_OBJECTS) { | |
150 | /* list objects via readdir, bucketwise */ | |
151 | using std::get; | |
152 | ||
153 | if (! fs) | |
154 | return; | |
155 | ||
156 | for (auto& fid_row : bucket_matrix) { | |
157 | auto& fid = get<0>(fid_row); // bucket | |
158 | std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket | |
159 | struct rgw_file_handle *bucket_fh = get<2>(fid); | |
160 | ||
161 | ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " << get<0>(fid) | |
162 | << dendl; | |
163 | ||
164 | bool eof = false; | |
165 | uint64_t offset = 0; | |
166 | int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &obj_vector, &eof, | |
167 | RGW_READDIR_FLAG_NONE); | |
168 | for (auto& obj : obj_vector) { | |
169 | std::cout << "fname: " << get<0>(obj) << " fid: " << get<1>(obj) | |
170 | << std::endl; | |
171 | } | |
172 | ASSERT_EQ(ret, 0); | |
173 | } | |
174 | } | |
175 | ||
1e59de90 TL |
176 | namespace rgw { |
177 | extern bool global_stop; | |
178 | } | |
7c673cae FG |
179 | |
180 | TEST(LibRGW, GETATTR_OBJECTS) { | |
181 | if (do_getattr) { | |
182 | using std::get; | |
183 | struct stat st; | |
184 | int ret; | |
185 | ||
1e59de90 | 186 | rgw::global_stop = true; |
7c673cae FG |
187 | |
188 | for (auto& fid_row : bucket_matrix) { | |
189 | auto& fid = get<0>(fid_row); // bucket | |
190 | std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket | |
191 | struct rgw_file_handle *bucket_fh = get<2>(fid); | |
192 | ||
193 | for (auto& obj : obj_vector) { | |
194 | struct rgw_file_handle *obj_fh = nullptr; | |
195 | std::string object_name = get<0>(obj); | |
196 | ret = rgw_lookup(fs, bucket_fh, get<0>(obj).c_str(), &obj_fh, | |
eafe8130 | 197 | nullptr /* stat */, 0 /* mask */, 0 /* flags */); |
7c673cae FG |
198 | ASSERT_EQ(ret, 0); |
199 | get<2>(obj) = obj_fh; // stash obj_fh for cleanup | |
200 | ASSERT_NE(get<2>(obj), nullptr); | |
201 | ret = rgw_getattr(fs, obj_fh, &st, | |
202 | RGW_GETATTR_FLAG_NONE); // now, getattr | |
203 | ASSERT_EQ(ret, 0); | |
204 | } | |
205 | } | |
206 | } | |
207 | } | |
208 | ||
209 | TEST(LibRGW, CLEANUP) { | |
210 | int ret = 0; | |
211 | using std::get; | |
212 | ||
213 | /* release file handles */ | |
214 | for (auto& fid_row : bucket_matrix) { | |
215 | auto& bucket = get<0>(fid_row); // bucket | |
216 | std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket | |
217 | for (auto& obj : obj_vector) { | |
218 | struct rgw_file_handle *obj_fh = get<2>(obj); | |
219 | if (obj_fh) { | |
220 | ret = rgw_fh_rele(fs, obj_fh, 0 /* flags */); | |
221 | ASSERT_EQ(ret, 0); | |
222 | } | |
223 | } | |
224 | // now the bucket | |
225 | struct rgw_file_handle *bucket_fh = get<2>(bucket); | |
226 | if (bucket_fh) { | |
227 | ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */); | |
228 | ASSERT_EQ(ret, 0); | |
229 | } | |
230 | } | |
231 | } | |
232 | ||
233 | TEST(LibRGW, UMOUNT) { | |
234 | if (! fs) | |
235 | return; | |
236 | ||
237 | int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE); | |
238 | ASSERT_EQ(ret, 0); | |
239 | } | |
240 | ||
241 | TEST(LibRGW, SHUTDOWN) { | |
1e59de90 | 242 | librgw_shutdown(h_rgw); |
7c673cae FG |
243 | } |
244 | ||
245 | int main(int argc, char *argv[]) | |
246 | { | |
20effc67 | 247 | auto args = argv_to_vec(argc, argv); |
7c673cae FG |
248 | env_to_vec(args); |
249 | ||
20effc67 | 250 | char* v = getenv("AWS_ACCESS_KEY_ID"); |
7c673cae FG |
251 | if (v) { |
252 | access_key = v; | |
253 | } | |
254 | ||
255 | v = getenv("AWS_SECRET_ACCESS_KEY"); | |
256 | if (v) { | |
257 | secret_key = v; | |
258 | } | |
259 | ||
20effc67 | 260 | string val; |
7c673cae FG |
261 | for (auto arg_iter = args.begin(); arg_iter != args.end();) { |
262 | if (ceph_argparse_witharg(args, arg_iter, &val, "--access", | |
263 | (char*) nullptr)) { | |
264 | access_key = val; | |
265 | } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret", | |
266 | (char*) nullptr)) { | |
267 | secret_key = val; | |
268 | } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid", | |
269 | (char*) nullptr)) { | |
270 | uid = val; | |
271 | } else if (ceph_argparse_flag(args, arg_iter, "--getattr", | |
272 | (char*) nullptr)) { | |
273 | do_getattr = true; | |
274 | } else { | |
275 | ++arg_iter; | |
276 | } | |
277 | } | |
278 | ||
11fdf7f2 | 279 | /* don't accidentally run as anonymous */ |
7c673cae FG |
280 | if ((access_key == "") || |
281 | (secret_key == "")) { | |
282 | std::cout << argv[0] << " no AWS credentials, exiting" << std::endl; | |
283 | return EPERM; | |
284 | } | |
285 | ||
286 | saved_args.argc = argc; | |
287 | saved_args.argv = argv; | |
288 | ||
289 | ::testing::InitGoogleTest(&argc, argv); | |
290 | return RUN_ALL_TESTS(); | |
291 | } |