Search is not available for this dataset
repo
stringlengths 2
152
⌀ | file
stringlengths 15
239
| code
stringlengths 0
58.4M
| file_length
int64 0
58.4M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 364
values |
|---|---|---|---|---|---|---|
null |
ceph-main/src/test/formatter.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "gtest/gtest.h"
#include "common/Formatter.h"
#include "common/HTMLFormatter.h"
#include <sstream>
#include <string>
using namespace ceph;
using std::ostringstream;
TEST(JsonFormatter, Simple1) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"a\":1,\"b\":2,\"c\":3}");
}
TEST(JsonFormatter, Simple2) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"bar\":{\"int\":263882790666240,\
\"unsigned\":9223372036854775809,\"float\":1.234},\
\"string\":\"str\"}");
}
TEST(JsonFormatter, CunningFloats) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_float("long", 1.0 / 7);
fmt.dump_float("big", 12345678901234567890.0);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"long\":0.14285714285714285,\"big\":1.2345678901234567e+19}");
}
TEST(JsonFormatter, Empty) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(XmlFormatter, Simple1) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><a>1</a><b>2</b><c>3</c></foo>");
}
TEST(XmlFormatter, Simple2) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><bar>\
<int>263882790666240</int>\
<unsigned>9223372036854775809</unsigned>\
<float>1.234</float>\
</bar><string>str</string>\
</foo>");
}
TEST(XmlFormatter, Empty) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(XmlFormatter, DumpStream1) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.dump_stream("blah") << "hithere";
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<blah>hithere</blah>");
}
TEST(XmlFormatter, DumpStream2) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah></foo>");
}
TEST(XmlFormatter, DumpStream3) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, DTD) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, Clear) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><blah>hithere</blah><pi>0.128</pi></foo>");
ostringstream oss2;
fmt.flush(oss2);
ASSERT_EQ(oss2.str(), "");
ostringstream oss3;
fmt.reset();
fmt.flush(oss3);
ASSERT_EQ(oss3.str(), "");
}
TEST(XmlFormatter, NamespaceTest) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section_in_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
"<blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, DumpFormatNameSpaceTest) {
ostringstream oss1;
XMLFormatter fmt(false);
fmt.dump_format_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/",
"%s","bar");
fmt.flush(oss1);
ASSERT_EQ(oss1.str(),
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">bar</foo>");
// Testing with a null ns..should be same as dump format
ostringstream oss2;
fmt.reset();
fmt.dump_format_ns("foo",NULL,"%s","bar");
fmt.flush(oss2);
ASSERT_EQ(oss2.str(),"<foo>bar</foo>");
}
TEST(HtmlFormatter, Simple1) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>a: 1</li><li>b: 2</li><li>c: 3</li></foo>");
}
TEST(HtmlFormatter, Simple2) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><bar>\
<li>int: 263882790666240</li>\
<li>unsigned: 9223372036854775809</li>\
<li>float: 1.234</li>\
</bar><li>string: str</li>\
</foo>");
}
TEST(HtmlFormatter, Empty) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(HtmlFormatter, DumpStream1) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.dump_stream("blah") << "hithere";
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<li>blah: hithere</li>");
}
TEST(HtmlFormatter, DumpStream2) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li></foo>");
}
TEST(HtmlFormatter, DumpStream3) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, DTD) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, Clear) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
ostringstream oss2;
fmt.flush(oss2);
ASSERT_EQ(oss2.str(), "");
ostringstream oss3;
fmt.reset();
fmt.flush(oss3);
ASSERT_EQ(oss3.str(), "");
}
TEST(HtmlFormatter, NamespaceTest) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section_in_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
"<li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, DumpFormatNameSpaceTest) {
ostringstream oss1;
HTMLFormatter fmt(false);
fmt.dump_format_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/",
"%s","bar");
fmt.flush(oss1);
ASSERT_EQ(oss1.str(),
"<li xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">foo: bar</li>");
// Testing with a null ns..should be same as dump format
ostringstream oss2;
fmt.reset();
fmt.dump_format_ns("foo",NULL,"%s","bar");
fmt.flush(oss2);
ASSERT_EQ(oss2.str(),"<li>foo: bar</li>");
}
| 9,231 | 25.005634 | 88 |
cc
|
null |
ceph-main/src/test/gather.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 Greg Farnum <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/Context.h"
#include "gtest/gtest.h"
class C_Checker : public Context {
public:
bool *finish_called;
int *result;
C_Checker(bool* _finish_called, int *r) :
finish_called(_finish_called), result(r) {}
void finish(int r) override { *finish_called = true; *result = r; }
};
TEST(ContextGather, Constructor) {
C_GatherBuilder gather(g_ceph_context);
EXPECT_FALSE(gather.has_subs());
EXPECT_TRUE(gather.get() == NULL);
}
TEST(ContextGather, OneSub) {
C_GatherBuilder gather(g_ceph_context);
Context *sub = gather.new_sub();
EXPECT_EQ(1, gather.num_subs_created());
EXPECT_EQ(1, gather.num_subs_remaining());
bool finish_called = false;
int result = 0;
C_Checker *checker = new C_Checker(&finish_called, &result);
gather.set_finisher(checker);
gather.activate();
sub->complete(0);
EXPECT_TRUE(finish_called);
EXPECT_EQ(0, result);
}
TEST(ContextGather, ManySubs) {
bool finish_called = false;
int result = 0;
C_GatherBuilder gather(g_ceph_context, new C_Checker(&finish_called, &result));
int sub_count = 8;
Context* subs[sub_count];
//create subs and test
for (int i = 0; i < sub_count; ++i) {
subs[i] = gather.new_sub();
EXPECT_EQ(i+1, gather.num_subs_created());
EXPECT_EQ(i+1, gather.num_subs_remaining());
}
EXPECT_TRUE(gather.has_subs());
gather.activate();
//finish all except one sub
for (int j = 0; j < sub_count - 1; ++j) {
subs[j]->complete(0);
EXPECT_FALSE(finish_called);
}
//finish last one and check asserts
subs[sub_count-1]->complete(0);
EXPECT_TRUE(finish_called);
}
TEST(ContextGather, AlternatingSubCreateFinish) {
C_GatherBuilder gather(g_ceph_context);
int sub_count = 8;
bool finish_called = false;
int result = 0;
C_Checker *checker = new C_Checker(&finish_called, &result);
gather.set_finisher(checker);
Context* subs[sub_count];
//create half the subs
for (int i = 0; i < sub_count / 2; ++i) {
subs[i] = gather.new_sub();
EXPECT_EQ(i + 1, gather.num_subs_created());
EXPECT_EQ(i + 1, gather.num_subs_remaining());
}
//alternate finishing first half of subs and creating last half of subs
for (int j = 0; j < sub_count / 2; ++j) {
subs[j]->complete(0);
subs[sub_count / 2 + j] = gather.new_sub();
}
gather.activate();
//finish last half of subs
for (int k = sub_count / 2; k < sub_count; ++k) {
subs[k]->complete(0);
}
EXPECT_TRUE(finish_called);
}
| 2,887 | 26.769231 | 81 |
cc
|
null |
ceph-main/src/test/gprof-helper.c
|
/* gprof-helper.c -- preload library to profile pthread-enabled programs
*
* Authors: Sam Hocevar <sam at zoy dot org>
* Daniel Jönsson <danieljo at fagotten dot org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the Do What The Fuck You Want To
* Public License as published by Banlu Kemiyatorn. See
* http://sam.zoy.org/projects/COPYING.WTFPL for more details.
*
* Compilation example:
* gcc -shared -fPIC gprof-helper.c -o gprof-helper.so -lpthread -ldl
*
* Usage example:
* LD_PRELOAD=./gprof-helper.so your_program
*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pthread.h>
static void * wrapper_routine(void *);
/* Original pthread function */
static int (*pthread_create_orig)(pthread_t *__restrict,
__const pthread_attr_t *__restrict,
void *(*)(void *),
void *__restrict) = NULL;
/* Library initialization function */
void wooinit(void) __attribute__((constructor));
void wooinit(void)
{
pthread_create_orig = dlsym(RTLD_NEXT, "pthread_create");
fprintf(stderr, "pthreads: using profiling hooks for gprof\n");
if(pthread_create_orig == NULL)
{
char *error = dlerror();
if(error == NULL)
{
error = "pthread_create is NULL";
}
fprintf(stderr, "%s\n", error);
exit(EXIT_FAILURE);
}
}
/* Our data structure passed to the wrapper */
typedef struct wrapper_s
{
void * (*start_routine)(void *);
void * arg;
pthread_mutex_t lock;
pthread_cond_t wait;
struct itimerval itimer;
} wrapper_t;
/* The wrapper function in charge for setting the itimer value */
static void * wrapper_routine(void * data)
{
/* Put user data in thread-local variables */
void * (*start_routine)(void *) = ((wrapper_t*)data)->start_routine;
void * arg = ((wrapper_t*)data)->arg;
/* Set the profile timer value */
setitimer(ITIMER_PROF, &((wrapper_t*)data)->itimer, NULL);
/* Tell the calling thread that we don't need its data anymore */
pthread_mutex_lock(&((wrapper_t*)data)->lock);
pthread_cond_signal(&((wrapper_t*)data)->wait);
pthread_mutex_unlock(&((wrapper_t*)data)->lock);
/* Call the real function */
return start_routine(arg);
}
/* Our wrapper function for the real pthread_create() */
int pthread_create(pthread_t *__restrict thread,
__const pthread_attr_t *__restrict attr,
void * (*start_routine)(void *),
void *__restrict arg)
{
wrapper_t wrapper_data;
int i_return;
/* Initialize the wrapper structure */
wrapper_data.start_routine = start_routine;
wrapper_data.arg = arg;
getitimer(ITIMER_PROF, &wrapper_data.itimer);
pthread_cond_init(&wrapper_data.wait, NULL);
pthread_mutex_init(&wrapper_data.lock, NULL);
pthread_mutex_lock(&wrapper_data.lock);
/* The real pthread_create call */
i_return = pthread_create_orig(thread,
attr,
&wrapper_routine,
&wrapper_data);
/* If the thread was successfully spawned, wait for the data
* to be released */
if(i_return == 0)
{
pthread_cond_wait(&wrapper_data.wait, &wrapper_data.lock);
}
pthread_mutex_unlock(&wrapper_data.lock);
pthread_mutex_destroy(&wrapper_data.lock);
pthread_cond_destroy(&wrapper_data.wait);
return i_return;
}
| 3,604 | 29.041667 | 72 |
c
|
null |
ceph-main/src/test/heartbeat_map.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/HeartbeatMap.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
using namespace ceph;
TEST(HeartbeatMap, Healthy) {
HeartbeatMap hm(g_ceph_context);
heartbeat_handle_d *h = hm.add_worker("one", pthread_self());
hm.reset_timeout(h, ceph::make_timespan(9), ceph::make_timespan(18));
bool healthy = hm.is_healthy();
ASSERT_TRUE(healthy);
hm.remove_worker(h);
}
TEST(HeartbeatMap, Unhealth) {
HeartbeatMap hm(g_ceph_context);
heartbeat_handle_d *h = hm.add_worker("one", pthread_self());
hm.reset_timeout(h, ceph::make_timespan(1), ceph::make_timespan(3));
sleep(2);
bool healthy = hm.is_healthy();
ASSERT_FALSE(healthy);
hm.remove_worker(h);
}
| 1,172 | 25.066667 | 71 |
cc
|
null |
ceph-main/src/test/kv_store_bench.cc
|
/*
* KvStoreBench.cc
*
* Created on: Aug 23, 2012
* Author: eleanor
*/
#include "test/kv_store_bench.h"
#include "key_value_store/key_value_structure.h"
#include "key_value_store/kv_flat_btree_async.h"
#include "include/rados/librados.hpp"
#include "test/omap_bench.h"
#include "common/ceph_argparse.h"
#include <string>
#include <climits>
#include <iostream>
#include <sstream>
#include <cmath>
using std::stringstream;
using std::cout;
using std::string;
using std::pair;
using std::make_pair;
using std::map;
using std::cerr;
KvStoreBench::KvStoreBench()
: entries(30),
ops(100),
clients(5),
key_size(5),
val_size(7),
max_ops_in_flight(8),
clear_first(false),
k(2),
cache_size(10),
cache_refresh(1),
client_name("admin"),
verbose(false),
kvs(NULL),
ops_in_flight(0),
rados_id("admin"),
pool_name("rbd"),
io_ctx_ready(false)
{
probs[25] = 'i';
probs[50] = 'u';
probs[75] = 'd';
probs[100] = 'r';
}
KvStoreBench::~KvStoreBench()
{
if (io_ctx_ready) {
librados::ObjectWriteOperation owo;
owo.remove();
io_ctx.operate(client_name + ".done-setting", &owo);
}
delete kvs;
}
int KvStoreBench::setup(int argc, const char** argv) {
auto args = argv_to_vec(argc, argv);
srand(time(NULL));
stringstream help;
help
<< "Usage: KvStoreBench [options]\n"
<< "Generate latency and throughput statistics for the key value store\n"
<< "\n"
<< "There are two sets of options - workload options affect the kind of\n"
<< "test to run, while algorithm options affect how the key value\n"
<< "store handles the workload.\n"
<< "\n"
<< "There are about entries / k objects in the store to begin with.\n"
<< "Higher k values reduce the likelihood of splits and the likelihood\n"
<< "multiple writers simultaneously faling to write because an object \n"
<< "is full, but having a high k also means there will be more object\n"
<< "contention.\n"
<< "\n"
<< "WORKLOAD OPTIONS\n"
<< " --name <client name> client name (default admin)\n"
<< " --entries <number> number of key/value pairs to store initially\n"
<< " (default " << entries << ")\n"
<< " --ops <number> number of operations to run\n"
<< " --keysize <number> number of characters per key (default " << key_size << ")\n"
<< " --valsize <number> number of characters per value (default " << val_size << ")\n"
<< " -t <number> number of operations in flight concurrently\n"
<< " (default " << max_ops_in_flight << ")\n"
<< " --clients <number> tells this instance how many total clients are. Note that\n"
<< " changing this does not change the number of clients."
<< " -d <insert> <update> <delete> <read> percent (1-100) of operations that should be of each type\n"
<< " (default 25 25 25 25)\n"
<< " -r <number> random seed to use (default time(0))\n"
<< "ALGORITHM OPTIONS\n"
<< " --kval k, where each object has a number of entries\n"
<< " >= k and <= 2k.\n"
<< " --cache-size number of index entries to keep in cache\n"
<< " (default " << cache_size << ")\n"
<< " --cache-refresh percent (1-100) of cache-size to read each \n"
<< " time the index is read\n"
<< "OTHER OPTIONS\n"
<< " --verbosity-on display debug output\n"
<< " --clear-first delete all existing objects in the pool before running tests\n";
for (unsigned i = 0; i < args.size(); i++) {
if(i < args.size() - 1) {
if (strcmp(args[i], "--ops") == 0) {
ops = atoi(args[i+1]);
} else if (strcmp(args[i], "--entries") == 0) {
entries = atoi(args[i+1]);
} else if (strcmp(args[i], "--kval") == 0) {
k = atoi(args[i+1]);
} else if (strcmp(args[i], "--keysize") == 0) {
key_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--valsize") == 0) {
val_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--cache-size") == 0) {
cache_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--cache-refresh") == 0) {
auto temp = atoi(args[i+1]);
assert (temp != 0);
cache_refresh = 100 / (double)temp;
} else if (strcmp(args[i], "-t") == 0) {
max_ops_in_flight = atoi(args[i+1]);
} else if (strcmp(args[i], "--clients") == 0) {
clients = atoi(args[i+1]);
} else if (strcmp(args[i], "-d") == 0) {
if (i + 4 >= args.size()) {
cout << "Invalid arguments after -d: there must be 4 of them."
<< std::endl;
continue;
} else {
probs.clear();
int sum = atoi(args[i + 1]);
probs[sum] = 'i';
sum += atoi(args[i + 2]);
probs[sum] = 'u';
sum += atoi(args[i + 3]);
probs[sum] = 'd';
sum += atoi(args[i + 4]);
probs[sum] = 'r';
if (sum != 100) {
cout << "Invalid arguments after -d: they must add to 100."
<< std::endl;
}
}
} else if (strcmp(args[i], "--name") == 0) {
client_name = args[i+1];
} else if (strcmp(args[i], "-r") == 0) {
srand(atoi(args[i+1]));
}
} else if (strcmp(args[i], "--verbosity-on") == 0) {
verbose = true;
} else if (strcmp(args[i], "--clear-first") == 0) {
clear_first = true;
} else if (strcmp(args[i], "--help") == 0) {
cout << help.str() << std::endl;
exit(1);
}
}
KvFlatBtreeAsync * kvba = new KvFlatBtreeAsync(k, client_name, cache_size,
cache_refresh, verbose);
kvs = kvba;
int r = rados.init(rados_id.c_str());
if (r < 0) {
cout << "error during init" << std::endl;
return r;
}
r = rados.conf_parse_argv(argc, argv);
if (r < 0) {
cout << "error during parsing args" << std::endl;
return r;
}
r = rados.conf_parse_env(NULL);
if (r < 0) {
cout << "error during parsing env" << std::endl;
return r;
}
r = rados.conf_read_file(NULL);
if (r < 0) {
cout << "error during read file" << std::endl;
return r;
}
r = rados.connect();
if (r < 0) {
cout << "error during connect: " << r << std::endl;
return r;
}
r = rados.ioctx_create(pool_name.c_str(), io_ctx);
if (r < 0) {
cout << "error creating io ctx" << std::endl;
rados.shutdown();
return r;
}
io_ctx_ready = true;
if (clear_first) {
librados::NObjectIterator it;
for (it = io_ctx.nobjects_begin(); it != io_ctx.nobjects_end(); ++it) {
librados::ObjectWriteOperation rm;
rm.remove();
io_ctx.operate(it->get_oid(), &rm);
}
}
int err = kvs->setup(argc, argv);
if (err < 0 && err != -17) {
cout << "error during setup of kvs: " << err << std::endl;
return err;
}
return 0;
}
string KvStoreBench::random_string(int len) {
string ret;
string alphanum = "0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < len; ++i) {
ret.push_back(alphanum[rand() % (alphanum.size() - 1)]);
}
return ret;
}
pair<string, bufferlist> KvStoreBench::rand_distr(bool new_elem) {
pair<string, bufferlist> ret;
if (new_elem) {
ret = make_pair(random_string(key_size),
KvFlatBtreeAsync::to_bl(random_string(val_size)));
key_set.insert(ret.first);
} else {
if (key_set.size() == 0) {
return make_pair("",KvFlatBtreeAsync::to_bl(""));
}
string get_string = random_string(key_size);
std::set<string>::iterator it = key_set.lower_bound(get_string);
if (it == key_set.end()) {
ret.first = *(key_set.rbegin());
} else {
ret.first = *it;
}
ret.second = KvFlatBtreeAsync::to_bl(random_string(val_size));
}
return ret;
}
int KvStoreBench::test_random_insertions() {
int err;
if (entries == 0) {
return 0;
}
stringstream prev_ss;
prev_ss << (atoi(client_name.c_str()) - 1);
string prev_rid = prev_ss.str();
stringstream last_ss;
if (client_name.size() > 1) {
last_ss << client_name.substr(0,client_name.size() - 2);
}
last_ss << clients - 1;
string last_rid = client_name == "admin" ? "admin" : last_ss.str();
map<string, bufferlist> big_map;
for (int i = 0; i < entries; i++) {
bufferlist bfr;
bfr.append(random_string(7));
big_map[random_string(5)] = bfr;
}
uint64_t uint;
time_t t;
if (client_name[client_name.size() - 1] != '0' && client_name != "admin") {
do {
librados::ObjectReadOperation oro;
oro.stat(&uint, &t, &err);
err = io_ctx.operate(prev_rid + ".done-setting", &oro, NULL);
if (verbose) cout << "reading " << prev_rid << ": err = " << err
<< std::endl;
} while (err != 0);
cout << "detected " << prev_rid << ".done-setting" << std::endl;
}
cout << "testing random insertions";
err = kvs->set_many(big_map);
if (err < 0) {
cout << "error setting things" << std::endl;
return err;
}
librados::ObjectWriteOperation owo;
owo.create(true);
io_ctx.operate(client_name + ".done-setting", &owo);
cout << "created " << client_name + ".done-setting. waiting for "
<< last_rid << ".done-setting" << std::endl;
do {
librados::ObjectReadOperation oro;
oro.stat(&uint, &t, &err);
err = io_ctx.operate(last_rid + ".done-setting", &oro, NULL);
} while (err != 0);
cout << "detected " << last_rid << ".done-setting" << std::endl;
return err;
}
void KvStoreBench::aio_callback_timed(int * err, void *arg) {
timed_args *args = reinterpret_cast<timed_args *>(arg);
ceph::mutex * ops_in_flight_lock = &args->kvsb->ops_in_flight_lock;
ceph::mutex * data_lock = &args->kvsb->data_lock;
ceph::condition_variable * op_avail = &args->kvsb->op_avail;
int *ops_in_flight = &args->kvsb->ops_in_flight;
if (*err < 0 && *err != -61) {
cerr << "Error during " << args->op << " operation: " << *err << std::endl;
}
args->sw.stop_time();
double time = args->sw.get_time();
args->sw.clear();
data_lock->lock();
//latency
args->kvsb->data.latency_jf.open_object_section("latency");
args->kvsb->data.latency_jf.dump_float(string(1, args->op).c_str(),
time);
args->kvsb->data.latency_jf.close_section();
//throughput
args->kvsb->data.throughput_jf.open_object_section("throughput");
args->kvsb->data.throughput_jf.dump_unsigned(string(1, args->op).c_str(),
ceph_clock_now());
args->kvsb->data.throughput_jf.close_section();
data_lock->unlock();
ops_in_flight_lock->lock();
(*ops_in_flight)--;
op_avail->notify_all();
ops_in_flight_lock->unlock();
delete args;
}
int KvStoreBench::test_teuthology_aio(next_gen_t distr,
const map<int, char> &probs)
{
int err = 0;
cout << "inserting initial entries..." << std::endl;
err = test_random_insertions();
if (err < 0) {
return err;
}
cout << "finished inserting initial entries. Waiting 10 seconds for everyone"
<< " to catch up..." << std::endl;
sleep(10);
cout << "done waiting. Starting random operations..." << std::endl;
std::unique_lock l{ops_in_flight_lock};
for (int i = 0; i < ops; i++) {
ceph_assert(ops_in_flight <= max_ops_in_flight);
if (ops_in_flight == max_ops_in_flight) {
op_avail.wait(l);
ceph_assert(ops_in_flight < max_ops_in_flight);
}
cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" << i + 1 << " / "
<< ops << std::endl;
timed_args * cb_args = new timed_args(this);
pair<string, bufferlist> kv;
int random = (rand() % 100);
cb_args->op = probs.lower_bound(random)->second;
switch (cb_args->op) {
case 'i':
kv = (((KvStoreBench *)this)->*distr)(true);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_set(kv.first, kv.second, false, aio_callback_timed,
cb_args, &cb_args->err);
break;
case 'u':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_set(kv.first, kv.second, true, aio_callback_timed,
cb_args, &cb_args->err);
break;
case 'd':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
key_set.erase(kv.first);
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_remove(kv.first, aio_callback_timed, cb_args, &cb_args->err);
break;
case 'r':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_get(kv.first, &cb_args->val, aio_callback_timed,
cb_args, &cb_args->err);
break;
default:
// shouldn't happen here
assert(false);
}
}
op_avail.wait(l, [this] { return ops_in_flight <= 0; });
print_time_data();
return err;
}
int KvStoreBench::test_teuthology_sync(next_gen_t distr,
const map<int, char> &probs)
{
int err = 0;
err = test_random_insertions();
if (err < 0) {
return err;
}
sleep(10);
for (int i = 0; i < ops; i++) {
StopWatch sw;
pair<char, double> d;
cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" << i + 1 << " / "
<< ops << std::endl;
pair<string, bufferlist> kv;
int random = (rand() % 100);
d.first = probs.lower_bound(random)->second;
switch (d.first) {
case 'i':
kv = (((KvStoreBench *)this)->*distr)(true);
if (kv.first == "") {
i--;
continue;
}
sw.start_time();
err = kvs->set(kv.first, kv.second, true);
sw.stop_time();
if (err < 0) {
cout << "Error setting " << kv << ": " << err << std::endl;
return err;
}
break;
case 'u':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
sw.start_time();
err = kvs->set(kv.first, kv.second, true);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error updating " << kv << ": " << err << std::endl;
return err;
}
break;
case 'd':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
key_set.erase(kv.first);
sw.start_time();
err = kvs->remove(kv.first);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error removing " << kv << ": " << err << std::endl;
return err;
}
break;
case 'r':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
bufferlist val;
sw.start_time();
err = kvs->get(kv.first, &kv.second);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error getting " << kv << ": " << err << std::endl;
return err;
}
break;
}
double time = sw.get_time();
d.second = time;
sw.clear();
//latency
data.latency_jf.open_object_section("latency");
data.latency_jf.dump_float(string(1, d.first).c_str(),
time);
data.latency_jf.close_section();
}
print_time_data();
return err;
}
void KvStoreBench::print_time_data() {
cout << "========================================================\n";
cout << "latency:" << std::endl;
data.latency_jf.flush(cout);
cout << std::endl;
cout << "throughput:" << std::endl;
data.throughput_jf.flush(cout);
cout << "\n========================================================"
<< std::endl;
}
int KvStoreBench::teuthology_tests() {
int err = 0;
if (max_ops_in_flight > 1) {
err = test_teuthology_aio(&KvStoreBench::rand_distr, probs);
} else {
err = test_teuthology_sync(&KvStoreBench::rand_distr, probs);
}
return err;
}
int main(int argc, const char** argv) {
KvStoreBench kvsb;
int err = kvsb.setup(argc, argv);
if (err == 0) cout << "setup successful" << std::endl;
else{
cout << "error " << err << std::endl;
return err;
}
err = kvsb.teuthology_tests();
if (err < 0) return err;
return 0;
};
| 16,597 | 28.376991 | 123 |
cc
|
null |
ceph-main/src/test/kv_store_bench.h
|
/*
* Benchmarking suite for key-value store
*
* September 2, 2012
* Eleanor Cawthon
* [email protected]
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#ifndef KVSTOREBENCH_H_
#define KVSTOREBENCH_H_
#include "key_value_store/key_value_structure.h"
#include "key_value_store/kv_flat_btree_async.h"
#include "common/Clock.h"
#include "global/global_context.h"
#include "common/Cond.h"
#include <string>
#include <climits>
#include <cfloat>
#include <iostream>
/**
* stores pairings from op type to time taken for that op (for latency), and to
* time that op completed to the nearest second (for throughput).
*/
struct kv_bench_data {
JSONFormatter throughput_jf;
JSONFormatter latency_jf;
};
class KvStoreBench;
/**
* keeps track of the number of milliseconds between two events - used to
* measure latency
*/
struct StopWatch {
utime_t begin_time;
utime_t end_time;
void start_time() {
begin_time = ceph_clock_now();
}
void stop_time() {
end_time = ceph_clock_now();
}
double get_time() {
return (end_time - begin_time) * 1000;
}
void clear() {
begin_time = end_time = utime_t();
}
};
/**
* arguments passed to the callback method when the op is being timed
*/
struct timed_args {
StopWatch sw;
//kv_bench_data data;
KvStoreBench * kvsb;
ceph::buffer::list val;
int err;
char op;
timed_args ()
: kvsb(NULL),
err(0),
op(' ')
{};
timed_args (KvStoreBench * k)
: kvsb(k),
err(0),
op(' ')
{}
};
typedef std::pair<std::string, ceph::buffer::list> (KvStoreBench::*next_gen_t)(bool new_elem);
class KvStoreBench {
protected:
//test setup variables set from command line
int entries; //the number of entries to write initially
int ops; //the number of operations to time
int clients; //the total number of clients running this test - used
//in the aio test to coordinate the end of the initial sets
int key_size;//number of characters in keys to write
int val_size;//number of characters in values to write
int max_ops_in_flight;
bool clear_first;//if true, remove all objects in pool before starting tests
//variables passed to KeyValueStructure
int k;
int cache_size; //number of index entries to store in cache
double cache_refresh; //cache_size / cache_refresh entries are read each time
//the index is read
std::string client_name;
bool verbose;//if true, display debug output
//internal
std::map<int, char> probs;//map of numbers from 1 to 100 to chars representing
//operation types - used to generate random operations
std::set<std::string> key_set;//set of keys already in the data set
KeyValueStructure * kvs;
kv_bench_data data;//stores throughput and latency from completed tests
ceph::mutex data_lock = ceph::make_mutex("data lock");
ceph::condition_variable op_avail; // signaled when an op completes
int ops_in_flight;//number of operations currently in progress
ceph::mutex ops_in_flight_lock =
ceph::make_mutex("KvStoreBench::ops_in_flight_lock");
//these are used for cleanup and setup purposes - they are NOT passed to kvs!
librados::Rados rados;
std::string rados_id;
std::string pool_name;
bool io_ctx_ready;
librados::IoCtx io_ctx;
/**
* Prints JSON-formatted throughput and latency data.
*
* Throughput data is {'char representing the operation type':time the op
* completed to the nearest second}
* Latency is {'char representing the operation type':time taken by the op}
*/
void print_time_data();
public:
KvStoreBench();
//after this is called, objects created by the KeyValueStructure remain.
~KvStoreBench();
/**
* parses command line arguments, sets up this rados instance, clears the
* pool if clear_first is true and calls kvs->setup.
*/
int setup(int argc, const char** argv);
/**
* Returns a string of random characters of length len
*/
std::string random_string(int len);
/**
* Inserts entries random keys and values asynchronously.
*/
int test_random_insertions();
/**
* calls test_random_insertions, then does ops randomly chosen operations
* asynchronously, with max_ops_in_flight operations at a time.
*/
int test_teuthology_aio(next_gen_t distr, const std::map<int, char> &probs);
/**
* calls test_random_insertions, then does ops randomly chosen operations
* synchronously.
*/
int test_teuthology_sync(next_gen_t distr, const std::map<int, char> &probs);
/**
* returns a key-value pair. If new_elem is true, the key is randomly
* generated. If it is false, the key is selected from the keys currently in
* the key set.
*/
std::pair<std::string, ceph::buffer::list> rand_distr(bool new_elem);
/**
* Called when aio operations complete. Updates data.
*/
static void aio_callback_timed(int * err, void *arg);
/**
* Calls test_ methods. Change to call, for example, multiple runs of a test
* with different settings. Currently just calls test_teuthology_aio.
*/
int teuthology_tests();
};
#endif /* KVSTOREBENCH_H_ */
| 5,252 | 26.217617 | 94 |
h
|
null |
ceph-main/src/test/libcephfs_config.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "gtest/gtest.h"
#include "include/compat.h"
#include "include/cephfs/libcephfs.h"
#include <sstream>
#include <string>
#include <string.h>
using std::string;
TEST(LibCephConfig, SimpleSet) {
struct ceph_mount_info *cmount;
int ret = ceph_create(&cmount, NULL);
ASSERT_EQ(ret, 0);
ret = ceph_conf_set(cmount, "log_max_new", "21");
ASSERT_EQ(ret, 0);
char buf[128];
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "log_max_new", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("21"), string(buf));
ceph_shutdown(cmount);
}
TEST(LibCephConfig, ArgV) {
struct ceph_mount_info *cmount;
int ret = ceph_create(&cmount, NULL);
ASSERT_EQ(ret, 0);
const char *argv[] = { "foo", "--log_max_new", "2",
"--key", "my-key", NULL };
size_t argc = (sizeof(argv) / sizeof(argv[0])) - 1;
ceph_conf_parse_argv(cmount, argc, argv);
char buf[128];
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "key", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("my-key"), string(buf));
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "log_max_new", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("2"), string(buf));
ceph_shutdown(cmount);
}
| 1,645 | 24.323077 | 70 |
cc
|
null |
ceph-main/src/test/librgw_file.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "global/global_init.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t h_rgw = nullptr;
string uid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
typedef std::tuple<string, uint64_t, struct rgw_file_handle*> fid_type; //in c++2014 can alias...
typedef std::tuple<fid_type, std::vector<fid_type>> bucket_type;
std::vector<fid_type> fids1;
std::vector<bucket_type> bucket_matrix;
bool do_getattr = false;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&h_rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(h_rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(h_rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
"/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, GETATTR_ROOT) {
if (do_getattr) {
if (! fs)
return;
struct stat st;
int ret = rgw_getattr(fs, fs->root_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
extern "C" {
static int r1_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
// don't need arg--it would point to fids1
fids1.push_back(fid_type(name, offset, nullptr /* handle */));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_BUCKETS) {
/* list buckets via readdir in fs root */
using std::get;
if (! fs)
return;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, fs->root_fh, &offset, r1_cb, &fids1, &eof,
RGW_READDIR_FLAG_NONE);
for (auto& fid : fids1) {
std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
<< std::endl;
/* push row for bucket into bucket_matrix */
bucket_matrix.push_back(bucket_type(fid, std::vector<fid_type>()));
}
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LOOKUP_BUCKETS) {
using std::get;
if (! fs)
return;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row);
// auto& obj_vector = get<1>(fid_row);
struct rgw_file_handle *rgw_fh = nullptr;
ASSERT_EQ(0, rgw_lookup(fs, fs->root_fh, get<0>(fid).c_str(), &rgw_fh,
nullptr /* stat */, 0 /* mask */, 0 /* flags */));
get<2>(fid) = rgw_fh;
ASSERT_NE(get<2>(fid), nullptr);
}
}
TEST(LibRGW, GETATTR_BUCKETS) {
if (do_getattr) {
using std::get;
if (! fs)
return;
struct stat st;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row);
struct rgw_file_handle *rgw_fh = get<2>(fid);
ASSERT_EQ(0, rgw_getattr(fs, rgw_fh, &st, RGW_GETATTR_FLAG_NONE));
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
std::vector<fid_type>& obj_vector = *(static_cast<std::vector<fid_type>*>(arg));
obj_vector.push_back(fid_type(name, offset, nullptr));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_OBJECTS) {
/* list objects via readdir, bucketwise */
using std::get;
if (! fs)
return;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
struct rgw_file_handle *bucket_fh = get<2>(fid);
ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " << get<0>(fid)
<< dendl;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &obj_vector, &eof,
RGW_READDIR_FLAG_NONE);
for (auto& obj : obj_vector) {
std::cout << "fname: " << get<0>(obj) << " fid: " << get<1>(obj)
<< std::endl;
}
ASSERT_EQ(ret, 0);
}
}
namespace rgw {
extern bool global_stop;
}
TEST(LibRGW, GETATTR_OBJECTS) {
if (do_getattr) {
using std::get;
struct stat st;
int ret;
rgw::global_stop = true;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
struct rgw_file_handle *bucket_fh = get<2>(fid);
for (auto& obj : obj_vector) {
struct rgw_file_handle *obj_fh = nullptr;
std::string object_name = get<0>(obj);
ret = rgw_lookup(fs, bucket_fh, get<0>(obj).c_str(), &obj_fh,
nullptr /* stat */, 0 /* mask */, 0 /* flags */);
ASSERT_EQ(ret, 0);
get<2>(obj) = obj_fh; // stash obj_fh for cleanup
ASSERT_NE(get<2>(obj), nullptr);
ret = rgw_getattr(fs, obj_fh, &st,
RGW_GETATTR_FLAG_NONE); // now, getattr
ASSERT_EQ(ret, 0);
}
}
}
}
TEST(LibRGW, CLEANUP) {
int ret = 0;
using std::get;
/* release file handles */
for (auto& fid_row : bucket_matrix) {
auto& bucket = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
for (auto& obj : obj_vector) {
struct rgw_file_handle *obj_fh = get<2>(obj);
if (obj_fh) {
ret = rgw_fh_rele(fs, obj_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
// now the bucket
struct rgw_file_handle *bucket_fh = get<2>(bucket);
if (bucket_fh) {
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(h_rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_flag(args, arg_iter, "--getattr",
(char*) nullptr)) {
do_getattr = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 7,245 | 23.815068 | 99 |
cc
|
null |
ceph-main/src/test/librgw_file_aw.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
bool do_create = false;
bool do_delete = false;
bool do_large = false;
bool do_verify = false;
bool do_hexdump = false;
string bucket_name = "sorrydave";
string object_name = "jocaml";
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
std::uniform_int_distribution<uint8_t> uint_dist;
std::mt19937 rng;
constexpr int iovcnt = 4;
constexpr int page_size = /* 65536 */ 4 * 1024*1024;
constexpr int seed = 8675309;
struct ZPage
{
char data[page_size];
uint64_t cksum;
}; /* ZPage */
struct ZPageSet
{
std::vector<ZPage*> pages;
struct iovec* iovs;
explicit ZPageSet(int n) {
pages.reserve(n);
iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = new ZPage();
for (int data_ix = 0; data_ix < page_size; ++data_ix) {
p->data[data_ix] = uint_dist(rng);
} // data_ix
p->cksum = XXH64(p->data, page_size, seed);
pages.emplace_back(p);
// and iovs
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
} // page_ix
}
int size() { return pages.size(); }
struct iovec* get_iovs() { return iovs; }
bool operator==(const ZPageSet& rhs) {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p1 = pages[page_ix];
ZPage* p2 = rhs.pages[page_ix];
if (p1->cksum != p2->cksum)
return false;
}
return true;
}
bool operator==(const rgw_uio* uio) {
uint64_t cksum;
int vix = 0, off = 0;
rgw_vio* vio = &uio->uio_vio[vix];
int vio_len = vio->vio_len;
char *data;
for (int ix = 0; ix < iovcnt; ++ix) {
ZPage* p1 = pages[ix];
data = static_cast<char*>(vio->vio_base) + off;
cksum = XXH64(data, page_size, seed);
if (p1->cksum != cksum) {
int r = memcmp(data, p1->data, page_size);
std::cout << "problem at ix " << ix << " r " << r<< std::endl;
return false;
}
off += page_size;
if (off >= vio_len) {
vio = &uio->uio_vio[++vix];
vio_len = vio->vio_len;
off = 0;
}
}
return true;
}
void cksum() {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
p->cksum = XXH64(p->data, page_size, seed);
}
}
void reset_iovs() { // VOP_READ and VOP_WRITE update
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
}
}
~ZPageSet() {
for (unsigned int ix = 0; ix < pages.size(); ++ix)
delete pages[ix];
free(iovs);
}
}; /* ZPageSet */
ZPageSet zp_set1{iovcnt}; // random data
ZPageSet zp_set2{iovcnt}; // random data in 64K pages
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LOOKUP_OBJECT) {
int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
}
#if 0
TEST(LibRGW, OPEN1) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, PUT_OBJECT) {
size_t nbytes;
struct iovec *iovs = zp_set1.get_iovs();
off_t offset = 0;
for (int ix : {0, 1}) {
struct iovec *iov = &iovs[ix];
// quick check
sprintf(static_cast<char*>(iov->iov_base), "::hi mom (%d)", ix);
iov->iov_len = 14;
int ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, iov->iov_len);
}
}
TEST(LibRGW, CLOSE1) {
int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, OPEN2) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, GET_OBJECT) {
size_t nread;
off_t offset = 0;
struct iovec *iovs = zp_set1.get_iovs();
for (int ix : {2 , 3}) {
struct iovec *iov = &iovs[ix];
int ret = rgw_read(fs, object_fh, offset, iovs[ix-2].iov_len, &nread,
iov->iov_base, RGW_READ_FLAG_NONE);
iov->iov_len = nread;
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nread, iovs[ix-2].iov_len);
std::cout << "read: " << static_cast<char*>(iov->iov_base) << std::endl;
}
}
TEST(LibRGW, CLOSE2) {
int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
#endif
TEST (LibRGW, LARGE1) {
if (do_large) {
int ret;
ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
size_t nbytes;
struct iovec *iovs = zp_set1.get_iovs();
off_t offset = 0;
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov = &iovs[ix];
// write iov->iov_len
ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, iov->iov_len);
}
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
} /* do_large */
}
TEST (LibRGW, LARGE2) {
if (do_large) {
int ret;
if (do_verify) {
ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
size_t nread;
off_t offset2 = 0;
struct iovec *iovs2 = zp_set2.get_iovs();
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov2 = &iovs2[ix];
ret = rgw_read(fs, object_fh, offset2, iov2->iov_len, &nread,
iov2->iov_base, RGW_READ_FLAG_NONE);
iov2->iov_len = nread;
offset2 += iov2->iov_len;
ASSERT_EQ(ret, 0);
}
zp_set1.cksum();
zp_set2.cksum();
ASSERT_TRUE(zp_set1 == zp_set2);
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
} /* do_large */
}
TEST(LibRGW, STAT_OBJECT) {
struct stat st;
int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
dout(15) << "rgw_getattr on " << object_name << " size = "
<< st.st_size << dendl;
}
TEST(LibRGW, DELETE_OBJECT) {
if (do_delete) {
int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CLEANUP) {
int ret;
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, RGW_FH_RELE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--verify",
(char*) nullptr)) {
do_verify = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--large",
(char*) nullptr)) {
do_large = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 10,902 | 23.949657 | 79 |
cc
|
null |
ceph-main/src/test/librgw_file_cd.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
bool do_create = false;
bool do_delete = false;
bool do_multi = false;
int multi_cnt = 10;
string bucket_name = "sorrydave";
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CREATE_BUCKET_MULTI) {
if (do_multi) {
int ret;
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
for (int ix = 0; ix < multi_cnt; ++ix) {
string bn = bucket_name;
bn += to_string(ix);
ret = rgw_mkdir(fs, fs->root_fh, bn.c_str(), &st, create_mask, &fh,
RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
std::cout << "created: " << bn << std::endl;
}
}
}
TEST(LibRGW, DELETE_BUCKET_MULTI) {
if (do_multi) {
for (int ix = 0; ix < multi_cnt; ++ix) {
string bn = bucket_name;
bn += to_string(ix);
int ret = rgw_unlink(fs, fs->root_fh, bn.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
}
TEST(LibRGW, CLEANUP) {
// do nothing
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--multi",
(char*) nullptr)) {
do_multi = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 4,764 | 22.706468 | 79 |
cc
|
null |
ceph-main/src/test/librgw_file_gp.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string uid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
bool do_pre_list = false;
bool do_put = false;
bool do_bulk = false;
bool do_writev = false;
bool do_readv = false;
bool do_verify = false;
bool do_get = false;
bool do_create = false;
bool do_delete = false;
bool do_stat = false; // stat objects (not buckets)
bool do_hexdump = false;
bool object_open = false;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name = "blastoff";
string object_name = "jocaml";
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
std::uniform_int_distribution<uint8_t> uint_dist;
std::mt19937 rng;
constexpr int iovcnt = 16;
constexpr int page_size = 65536;
constexpr int seed = 8675309;
struct ZPage
{
char data[page_size];
uint64_t cksum;
}; /* ZPage */
struct ZPageSet
{
std::vector<ZPage*> pages;
struct iovec* iovs;
explicit ZPageSet(int n) {
pages.reserve(n);
iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = new ZPage();
for (int data_ix = 0; data_ix < page_size; ++data_ix) {
p->data[data_ix] = uint_dist(rng);
} // data_ix
p->cksum = XXH64(p->data, page_size, seed);
pages.emplace_back(p);
// and iovs
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
} // page_ix
}
int size() { return pages.size(); }
struct iovec* get_iovs() { return iovs; }
bool operator==(const ZPageSet& rhs) {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p1 = pages[page_ix];
ZPage* p2 = rhs.pages[page_ix];
if (p1->cksum != p2->cksum)
return false;
}
return true;
}
bool operator==(const rgw_uio* uio) {
uint64_t cksum;
int vix = 0, off = 0;
rgw_vio* vio = &uio->uio_vio[vix];
int vio_len = vio->vio_len;
char *data;
for (int ix = 0; ix < iovcnt; ++ix) {
ZPage* p1 = pages[ix];
data = static_cast<char*>(vio->vio_base) + off;
cksum = XXH64(data, page_size, seed);
if (p1->cksum != cksum) {
int r = memcmp(data, p1->data, page_size);
std::cout << "problem at ix " << ix << " r " << r<< std::endl;
return false;
}
off += page_size;
if (off >= vio_len) {
vio = &uio->uio_vio[++vix];
vio_len = vio->vio_len;
off = 0;
}
}
return true;
}
void cksum() {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
p->cksum = XXH64(p->data, page_size, seed);
}
}
void reset_iovs() { // VOP_READ and VOP_WRITE update
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
}
}
~ZPageSet() {
for (unsigned int ix = 0; ix < pages.size(); ++ix)
delete pages[ix];
free(iovs);
}
}; /* ZPageSet */
rgw_uio uio[1];
ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
"/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat *st, uint32_t st_mask,
uint32_t flags) {
// don't need arg--it would point to fids
fids.push_back(fid_type(name, offset, nullptr));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_OBJECTS) {
if (do_pre_list) {
/* list objects via readdir, bucketwise */
using std::get;
ldout(g_ceph_context, 0) << __func__ << " readdir on bucket "
<< bucket_name << dendl;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids,
&eof, RGW_READDIR_FLAG_NONE);
for (auto& fid : fids) {
std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
<< std::endl;
}
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_OBJECT) {
if (do_get || do_stat || do_put || do_bulk || do_readv || do_writev) {
int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, OBJ_OPEN) {
if (do_get || do_put || do_readv || do_writev) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(ret, 0);
object_open = true;
}
}
TEST(LibRGW, PUT_OBJECT) {
if (do_put) {
size_t nbytes;
string data = "hi mom"; // fix this
int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
ret = rgw_close(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, GET_OBJECT) {
if (do_get) {
char sbuf[512];
memset(sbuf, 0, 512);
size_t nread;
int ret = rgw_read(fs, object_fh, 0 /* off */, 512 /* len */, &nread, sbuf,
RGW_READ_FLAG_NONE);
ASSERT_EQ(ret, 0);
buffer::list bl;
bl.push_back(buffer::create_static(nread, sbuf));
if (do_hexdump) {
dout(15) << "";
bl.hexdump(*_dout);
*_dout << dendl;
}
}
}
TEST(LibRGW, STAT_OBJECT) {
if (do_stat) {
struct stat st;
int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
dout(15) << "rgw_getattr on " << object_name << " size = "
<< st.st_size << dendl;
}
}
TEST(LibRGW, WRITE_READ_VERIFY)
{
if (do_bulk && do_put) {
ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
struct iovec *iovs = zp_set1.get_iovs();
/* read after write POSIX-style */
size_t nbytes, off = 0;
for (int ix = 0; ix < 16; ++ix, off += page_size) {
struct iovec *iov = &iovs[ix];
int ret = rgw_write(fs, object_fh, off, page_size, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, size_t(page_size));
}
zp_set1.reset_iovs();
}
}
/* "functions that call alloca are not inlined"
* --alexandre oliva
* http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html
*/
#define alloca_uio() \
do {\
int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio); \
uio = static_cast<rgw_uio*>(alloca(uiosz)); \
memset(uio, 0, uiosz); \
uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio)); \
} while (0); \
TEST(LibRGW, WRITEV)
{
if (do_writev) {
rgw_uio* uio;
struct iovec *iovs = zp_set1.get_iovs();
alloca_uio();
ASSERT_NE(uio, nullptr);
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov = &iovs[ix];
rgw_vio *vio = &(uio->uio_vio[ix]);
vio->vio_base = iov->iov_base;
vio->vio_len = iov->iov_len;
vio->vio_u1 = iov; // private data
}
uio->uio_cnt = iovcnt;
uio->uio_offset = iovcnt * page_size;
int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, READV)
{
if (do_readv) {
memset(uio, 0, sizeof(rgw_uio));
uio->uio_offset = 0; // ok, it was already 0
uio->uio_resid = UINT64_MAX;
int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE);
ASSERT_EQ(ret, 0);
buffer::list bl;
for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) {
rgw_vio *vio = &(uio->uio_vio[ix]);
bl.push_back(
buffer::create_static(vio->vio_len,
static_cast<char*>(vio->vio_base)));
}
/* length check */
ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size});
if (do_hexdump) {
dout(15) << "";
bl.hexdump(*_dout);
*_dout << dendl;
}
}
}
TEST(LibRGW, READV_AFTER_WRITEV)
{
/* checksum data */
if (do_readv && do_writev && do_verify) {
ASSERT_TRUE(zp_set1 == uio);
}
}
TEST(LibRGW, DELETE_OBJECT) {
if (do_delete) {
int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CLEANUP) {
if (do_readv) {
// release resources
ASSERT_NE(uio->uio_rele, nullptr);
if (uio->uio_rele) {
uio->uio_rele(uio, RGW_UIO_NONE);
}
}
int ret;
if (object_open) {
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_flag(args, arg_iter, "--get",
(char*) nullptr)) {
do_get = true;
} else if (ceph_argparse_flag(args, arg_iter, "--stat",
(char*) nullptr)) {
do_stat = true;
} else if (ceph_argparse_flag(args, arg_iter, "--put",
(char*) nullptr)) {
do_put = true;
} else if (ceph_argparse_flag(args, arg_iter, "--bulk",
(char*) nullptr)) {
do_bulk = true;
} else if (ceph_argparse_flag(args, arg_iter, "--writev",
(char*) nullptr)) {
do_writev = true;
} else if (ceph_argparse_flag(args, arg_iter, "--readv",
(char*) nullptr)) {
do_readv = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verify",
(char*) nullptr)) {
do_verify = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--prelist",
(char*) nullptr)) {
do_pre_list = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 13,117 | 24.226923 | 80 |
cc
|
null |
ceph-main/src/test/librgw_file_marker.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <fstream>
#include <stack>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "rgw_lib_frontend.h" // direct requests
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
using namespace rgw;
using std::get;
using std::string;
librgw_t rgw_h = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
CephContext* cct = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name("dmarker");
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
/* Unused
ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
*/
std::stack<obj_rec> obj_stack;
std::deque<obj_rec> cleanup_queue;
typedef std::vector<obj_rec> obj_vec;
typedef std::tuple<obj_rec, obj_vec> dirs1_rec;
typedef std::vector<dirs1_rec> dirs1_vec;
dirs1_vec dirs_vec;
struct obj_rec_st
{
const obj_rec& obj;
const struct stat& st;
obj_rec_st(const obj_rec& _obj, const struct stat& _st)
: obj(_obj), st(_st) {}
};
/* Unused
ostream& operator<<(ostream& os, const obj_rec_st& rec)
{
RGWFileHandle* rgw_fh = rec.obj.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rgw_fh->full_object_name()
<< " (" << rgw_fh->object_name() << "): "
<< type;
const struct stat& st = rec.st;
switch(uint8_t(rgw_fh->is_dir())) {
case 1:
os << " mode: " << st.st_mode;
os << " nlinks: " << st.st_nlink;
break;
case 0:
default:
os << " mode: " << st.st_mode;
os << " size: " << st.st_size;
// xxx
break;
}
}
return os;
}
*/
bool do_marker1 = false;
bool do_marker2 = true;
bool do_create = false;
bool do_delete = false;
bool verbose = false;
string marker_dir("nfs_marker");
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *marker_fh;
uint32_t marker_nobjs = 2*1024;
std::deque<obj_rec> marker_objs;
using dirent_t = std::tuple<std::string, uint64_t>;
struct dirent_vec
{
std::vector<dirent_t> obj_names;
uint32_t count;
dirent_vec() : count(0) {}
};
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, TVAR) {
typedef boost::variant<uint64_t*, const char*> readdir_offset;
uint64_t i1{64001};
std::string s1{"blunderbuss"};
readdir_offset v1{&i1};
readdir_offset v2{s1.c_str()};
readdir_offset v3{static_cast<const char*>(nullptr)};
uint64_t* pi1 = get<uint64_t*>(v1);
ASSERT_NE(pi1, nullptr);
std::cout << "read i1: " << *pi1 << std::endl;
const char* ps1 = get<const char*>(v2);
ASSERT_NE(ps1, nullptr);
std::cout << "read s1: " << ps1 << std::endl;
const char* ps3 = get<const char*>(v3);
ASSERT_EQ(ps3, nullptr);
std::cout << "read s3: " << ps3 << std::endl;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
cct = static_cast<RGWLibFS*>(fs->fs_private)->get_context();
}
TEST(LibRGW, MARKER1_SETUP_BUCKET) {
/* "large" directory enumeration test. this one deals only with
* file objects */
struct stat st;
int ret;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
(void) rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! bucket_fh) {
if (do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
ASSERT_NE(bucket_fh, nullptr);
(void) rgw_lookup(fs, bucket_fh, marker_dir.c_str(), &marker_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! marker_fh) {
if (do_create) {
ret = rgw_mkdir(fs, bucket_fh, marker_dir.c_str(), &st, create_mask,
&marker_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
ASSERT_NE(marker_fh, nullptr);
}
TEST(LibRGW, MARKER1_SETUP_OBJECTS)
{
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_create) {
int ret;
for (uint32_t ix = 0; ix < marker_nobjs; ++ix) {
std::string object_name("f_");
object_name += to_string(ix);
obj_rec obj{object_name, nullptr, marker_fh, nullptr};
// lookup object--all operations are by handle
ret = rgw_lookup(fs, marker_fh, obj.name.c_str(), &obj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
obj.rgw_fh = get_rgwfh(obj.fh);
// open object--open transaction
ret = rgw_open(fs, obj.fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_TRUE(obj.rgw_fh->is_open());
// unstable write data
size_t nbytes;
string data("data for ");
data += object_name;
int ret = rgw_write(fs, obj.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
// commit transaction (write on close)
ret = rgw_close(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
if (verbose) {
/* XXX std:cout fragged...did it get /0 in the stream
* somewhere? */
printf("created: %s:%s\n", bucket_name.c_str(), obj.name.c_str());
}
// save for cleanup
marker_objs.push_back(obj);
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
dirent_vec& dvec =
*(static_cast<dirent_vec*>(arg));
printf("%s bucket=%s dir=%s iv count=%d called back name=%s flags=%d\n",
__func__,
bucket_name.c_str(),
marker_dir.c_str(),
dvec.count,
name,
flags);
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
dvec.obj_names.push_back(dirent_t{std::move(name_str), offset});
}
return true; /* XXX */
}
}
TEST(LibRGW, MARKER1_READDIR)
{
if (do_marker1) {
using std::get;
dirent_vec dvec;
uint64_t offset = 0;
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir(fs, marker_fh, &offset, r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_DOTDOT);
ASSERT_EQ(ret, 0);
ASSERT_GE(dvec.obj_names.size(), 0);
ASSERT_EQ(offset, get<1>(dvec.obj_names.back())); // cookie check
++dvec.count;
} while(!eof);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER2_READDIR)
{
if (do_marker2) {
using std::get;
dirent_vec dvec;
std::string marker{""};
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir2(fs, marker_fh,
(marker.length() > 0) ? marker.c_str() : nullptr,
r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_GE(dvec.obj_names.size(), 0);
marker = get<0>(dvec.obj_names.back());
++dvec.count;
} while((!eof) && dvec.count < 4);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER1_OBJ_CLEANUP)
{
int rc;
for (auto& obj : marker_objs) {
if (obj.fh) {
if (do_delete) {
if (verbose) {
std::cout << "unlinking: " << bucket_name << ":" << obj.name
<< std::endl;
}
rc = rgw_unlink(fs, marker_fh, obj.name.c_str(), RGW_UNLINK_FLAG_NONE);
}
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
marker_objs.clear();
}
TEST(LibRGW, CLEANUP) {
int rc;
if (do_marker1) {
cleanup_queue.push_back(
obj_rec{bucket_name, bucket_fh, fs->root_fh, get_rgwfh(fs->root_fh)});
}
for (auto& elt : cleanup_queue) {
if (elt.fh) {
rc = rgw_fh_rele(fs, elt.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
cleanup_queue.clear();
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--nobjs",
(char*) nullptr)) {
marker_nobjs = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--marker1",
(char*) nullptr)) {
do_marker1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 12,713 | 24.633065 | 78 |
cc
|
null |
ceph-main/src/test/librgw_file_nfsns.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <fstream>
#include <stack>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "rgw_lib.h"
#include "rgw_lib_frontend.h" // direct requests
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
using namespace rgw; // g_rgwlib
namespace {
using namespace rgw;
using std::get;
using std::string;
librgw_t rgw_h = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
CephContext* cct = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t magic_uid = 1701;
uint32_t magic_gid = 9876;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name("nfsroot");
string dirs1_bucket_name("bdirs1");
string readf_name("toyland");
string readf_out_name("rgwlib_readf.out");
std::string writef_name{"bigbird"};
int n_dirs1_dirs = 3;
int n_dirs1_objs = 2;
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
std::stack<obj_rec> obj_stack;
std::deque<obj_rec> cleanup_queue;
typedef std::vector<obj_rec> obj_vec;
typedef std::tuple<obj_rec, obj_vec> dirs1_rec;
typedef std::vector<dirs1_rec> dirs1_vec;
dirs1_vec dirs_vec;
struct obj_rec_st
{
const obj_rec& obj;
const struct stat& st;
obj_rec_st(const obj_rec& _obj, const struct stat& _st)
: obj(_obj), st(_st) {}
};
ostream& operator<<(ostream& os, const obj_rec_st& rec)
{
RGWFileHandle* rgw_fh = rec.obj.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rgw_fh->full_object_name()
<< " (" << rgw_fh->object_name() << "): "
<< type;
const struct stat& st = rec.st;
switch(uint8_t(rgw_fh->is_dir())) {
case 1:
os << " mode: " << st.st_mode;
os << " nlinks: " << st.st_nlink;
break;
case 0:
default:
os << " mode: " << st.st_mode;
os << " size: " << st.st_size;
// xxx
break;
}
}
return os;
}
bool do_hier1 = false;
bool do_dirs1 = false;
bool do_readf = false;
bool do_writef = false;
bool do_marker1 = false;
bool do_create = false;
bool do_delete = false;
bool do_rename = false;
bool do_setattr = false;
bool verbose = false;
string marker_dir("nfs_marker");
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *marker_fh;
static constexpr int marker_nobjs = 2*1024;
std::deque<obj_rec> marker_objs;
using dirent_t = std::tuple<std::string, uint64_t>;
struct dirent_vec
{
std::vector<dirent_t> obj_names;
uint32_t count;
dirent_vec() : count(0) {}
};
obj_rec dirs1_b{dirs1_bucket_name, nullptr, nullptr, nullptr};
dirs1_vec renames_vec;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT_NOROOT) {
/* do a mount at root="" and verify that it's root is "/" */
struct rgw_fs *fs = nullptr;
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
auto& root_fh = static_cast<RGWLibFS*>(fs->fs_private)->get_fh();
ASSERT_EQ(root_fh.get_name(), "/");
ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
cct = static_cast<RGWLibFS*>(fs->fs_private)->get_context();
}
TEST(LibRGW, SETUP_HIER1)
{
if (do_hier1) {
(void) rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! bucket_fh) {
if (do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int rc = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st,
create_mask, &bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(bucket_fh, nullptr);
if (do_create) {
/* create objects directly */
std::vector<std::string> obj_names =
{"foo/bar/baz/quux",
"foo/f1",
"foo/f2",
"foo/bar/f1",
"foo/bar/d1/",
"foo/bar/baz/hungry",
"foo/bar/baz/hungry/",
"foo/bar/baz/momma",
"foo/bar/baz/bear/",
"foo/bar/baz/sasquatch",
"foo/bar/baz/sasquatch/",
"foo/bar/baz/frobozz"};
buffer::list bl; // empty object
RGWLibFS *fs_private = static_cast<RGWLibFS*>(fs->fs_private);
for (const auto& obj_name : obj_names) {
if (verbose) {
std::cout << "creating: " << bucket_name << ":" << obj_name
<< std::endl;
}
RGWPutObjRequest req(cct,
g_rgwlib->get_driver()->get_user(fs_private->get_user()->user_id),
bucket_name, obj_name, bl);
int rc = g_rgwlib->get_fe()->execute_req(&req);
int rc2 = req.get_ret();
ASSERT_EQ(rc, 0);
ASSERT_EQ(rc2, 0);
}
}
}
}
TEST(LibRGW, SETUP_DIRS1) {
if (do_dirs1) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
dirs1_b.parent_fh = fs->root_fh;
(void) rgw_lookup(fs, dirs1_b.parent_fh, dirs1_bucket_name.c_str(),
&dirs1_b.fh, nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! dirs1_b.fh) {
if (do_create) {
rc = rgw_mkdir(fs, dirs1_b.parent_fh, dirs1_b.name.c_str(), &st,
create_mask, &dirs1_b.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
} else {
/* no top-level dir and can't create it--skip remaining tests */
return;
}
}
dirs1_b.sync();
/* make top-level dirs */
int d_ix;
obj_vec ovec;
for (d_ix = 0; d_ix < n_dirs1_dirs; ++d_ix) {
std::string dname{"dir_"};
dname += to_string(d_ix);
obj_rec dir{dname, nullptr, dirs1_b.fh, nullptr};
ovec.clear();
(void) rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! dir.fh) {
if (do_create) {
rc = rgw_mkdir(fs, dir.parent_fh, dir.name.c_str(), &st, create_mask,
&dir.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(dir.fh, nullptr);
dir.sync();
ASSERT_NE(dir.rgw_fh, nullptr);
ASSERT_TRUE(dir.rgw_fh->is_dir());
int f_ix;
for (f_ix = 0; f_ix < n_dirs1_objs; ++f_ix) {
/* child dir */
std::string sdname{"sdir_"};
sdname += to_string(f_ix);
obj_rec sdir{sdname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sdir.parent_fh, sdir.name.c_str(), &sdir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sdir.fh) {
if (do_create) {
rc = rgw_mkdir(fs, sdir.parent_fh, sdir.name.c_str(), &st,
create_mask, &sdir.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(sdir.fh, nullptr); // suppress !lookup && !create case
sdir.sync();
ASSERT_TRUE(sdir.rgw_fh->is_dir());
ovec.push_back(sdir);
/* child file */
std::string sfname{"sfile_"};
sfname += to_string(f_ix);
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
if (do_create) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
/* because we made it the hard way, fixup attributes */
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
sf.rgw_fh->create_stat(&st, create_mask);
/* open handle */
rc = rgw_open(fs, sf.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(sf.rgw_fh->is_open());
/* stage seq write */
size_t nbytes;
string data = "data for " + sf.name;
rc = rgw_write(fs, sf.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
rc = rgw_close(fs, sf.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
} else {
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
}
if (sf.fh)
ovec.push_back(sf);
}
dirs_vec.push_back(dirs1_rec{dir, ovec});
}
} /* dirs1 top-level !exist */
}
TEST(LibRGW, SETATTR) {
if (do_dirs1) {
if (do_setattr) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
std::string dname{"dir_0"};
obj_rec dir{dname, nullptr, dirs1_b.fh, nullptr};
/* dir_0 MUST exist and MUST be resident */
(void) rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_NE(dir.fh, nullptr);
dir.sync();
ASSERT_NE(dir.rgw_fh, nullptr);
ASSERT_TRUE(dir.rgw_fh->is_dir());
/* child file */
std::string sfname{"setattr_file_0"};
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
/* because we made it the hard way, fixup attributes */
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
sf.rgw_fh->create_stat(&st, create_mask);
/* open handle */
rc = rgw_open(fs, sf.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(sf.rgw_fh->is_open());
/* stage seq write */
size_t nbytes;
string data = "data for " + sf.name;
rc = rgw_write(fs, sf.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
rc = rgw_close(fs, sf.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
} else {
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
}
/* sf MUST now be materialized--now change it's attributes */
st.st_uid = magic_uid;
st.st_gid = magic_gid;
rc = rgw_setattr(fs, sf.fh, &st, create_mask, RGW_SETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
/* force evict--subsequent lookups must reload */
static_cast<RGWLibFS*>(fs->fs_private)->release_evict(sf.rgw_fh);
sf.clear();
/* revalidate -- expect magic uid and gid */
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
sf.sync();
ASSERT_NE(sf.fh, nullptr);
memset(&st, 0, sizeof(struct stat)); /* nothing up my sleeve... */
rc = rgw_getattr(fs, sf.fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(st.st_uid, magic_uid);
ASSERT_EQ(st.st_gid, magic_gid);
/* release 1 ref on sf */
rgw_fh_rele(fs, sf.fh, RGW_FH_RELE_FLAG_NONE);
/* release 1 ref on dir */
rgw_fh_rele(fs, dir.fh, RGW_FH_RELE_FLAG_NONE);
} /* dirs1 */
}
}
TEST(LibRGW, RGW_CREATE_DIRS1) {
/* verify rgw_create (create [empty] file objects the easy way) */
if (do_dirs1) {
if (do_create) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
for (auto& dirs_rec : dirs_vec) {
/* create 1 more file in each sdir */
obj_rec& dir = get<0>(dirs_rec);
std::string sfname{"sfile_" + to_string(n_dirs1_objs)};
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
rc = rgw_create(fs, sf.parent_fh, sf.name.c_str(), &st, create_mask,
&sf.fh, 0 /* posix flags */, RGW_CREATE_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
sf.sync();
}
n_dirs1_objs++;
}
}
}
TEST(LibRGW, RGW_SETUP_RENAME1) {
/* verify rgw_create (create [empty] file objects the easy way) */
if (do_rename) {
int rc;
struct stat st;
obj_vec ovec;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
for (int b_ix : {0, 1}) {
std::string bname{"brename" + to_string(b_ix)};
obj_rec brec{bname, nullptr, nullptr, nullptr};
(void) rgw_lookup(fs, fs->root_fh, brec.name.c_str(), &brec.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! brec.fh) {
if (do_create) {
struct stat st;
int rc = rgw_mkdir(fs, fs->root_fh, brec.name.c_str(), &st,
create_mask, &brec.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(brec.fh, nullptr);
brec.sync();
st.st_mode = 644; /* file mask */
for (int f_ix : {0, 1}) {
std::string rfname{"rfile_"};
rfname += to_string(f_ix);
obj_rec rf{rfname, nullptr, brec.fh, nullptr};
(void) rgw_lookup(fs, rf.parent_fh, rf.name.c_str(), &rf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! rf.fh) {
rc = rgw_create(fs, rf.parent_fh, rf.name.c_str(), &st, create_mask,
&rf.fh, 0 /* posix flags */, RGW_CREATE_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
rf.sync();
ovec.push_back(rf);
}
renames_vec.push_back(dirs1_rec{brec, ovec});
ovec.clear();
} /* b_ix */
}
}
TEST(LibRGW, RGW_INTRABUCKET_RENAME1) {
/* rgw_rename a file within a bucket */
if (do_rename) {
int rc;
obj_rec& bdir0 = get<0>(renames_vec[0]);
obj_rec& src_obj = get<1>(renames_vec[0])[0];
std::string rfname{"rfile_r0"};
if (verbose) {
std::cout << "rename file " << src_obj.name << " to "
<< rfname << " (bucket " << bdir0.name << ")"
<< std::endl;
}
rc = rgw_rename(fs, bdir0.fh, src_obj.name.c_str(), bdir0.fh,
rfname.c_str(), RGW_RENAME_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
TEST(LibRGW, RGW_CROSSBUCKET_RENAME1) {
/* rgw_rename a file within a bucket */
if (do_rename) {
int rc;
obj_rec& bdir0 = get<0>(renames_vec[0]);
obj_rec& bdir1 = get<0>(renames_vec[1]);
obj_rec& src_obj = get<1>(renames_vec[0])[1];
std::string rfname{"rfile_rhilldog"};
if (verbose) {
std::cout << "rename file " << src_obj.name
<< " (bucket " << bdir0.name << ") to "
<< rfname << " (bucket " << bdir1.name << ")"
<< std::endl;
}
rc = rgw_rename(fs, bdir0.fh, src_obj.name.c_str(), bdir1.fh,
rfname.c_str(), RGW_RENAME_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
#if 0 /* XXX inconsistent failure here */
TEST(LibRGW, BAD_DELETES_DIRS1) {
if (do_dirs1) {
int rc;
if (dirs_vec.size() == 0) {
/* skip */
return;
}
if (do_delete) {
/* try to unlink a non-empty directory (bucket) */
rc = rgw_unlink(fs, dirs1_b.parent_fh, dirs1_b.name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_NE(rc, 0);
}
/* try to unlink a non-empty directory (non-bucket) */
obj_rec& sdir_0 = get<1>(dirs_vec[0])[0];
ASSERT_EQ(sdir_0.name, "sdir_0");
ASSERT_TRUE(sdir_0.rgw_fh->is_dir());
/* XXX we can't enforce this currently */
#if 0
ASSERT_EQ(sdir_0.name, "sdir_0");
ASSERT_TRUE(sdir_0.rgw_fh->is_dir());
rc = rgw_unlink(fs, sdir_0.parent_fh, sdir_0.name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_NE(rc, 0);
#endif
}
}
#endif
TEST(LibRGW, GETATTR_DIRS1)
{
if (do_dirs1) {
int rc;
struct stat st;
for (auto& dirs_rec : dirs_vec) {
obj_rec& dir = get<0>(dirs_rec);
if (verbose) {
std::cout << "scanning objects in "
<< dir.rgw_fh->full_object_name()
<< std::endl;
}
for (auto& sobj : get<1>(dirs_rec)) {
rc = rgw_getattr(fs, sobj.fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
/* validate, pretty-print */
if (sobj.rgw_fh->object_name().find("sfile") != std::string::npos) {
ASSERT_TRUE(sobj.rgw_fh->is_file());
ASSERT_TRUE(S_ISREG(st.st_mode));
}
if (sobj.rgw_fh->object_name().find("sdir") != std::string::npos) {
ASSERT_TRUE(sobj.rgw_fh->is_dir());
ASSERT_TRUE(S_ISDIR(st.st_mode));
}
/* validate Unix owners */
ASSERT_EQ(st.st_uid, owner_uid);
ASSERT_EQ(st.st_gid, owner_gid);
if (verbose) {
obj_rec_st rec_st{sobj, st};
std::cout << "\t"
<< rec_st
<< std::endl;
}
}
}
}
}
TEST(LibRGW, READ_DIRS1)
{
if (do_dirs1) {
int rc;
char buf[256];
size_t nread;
for (auto& dirs_rec : dirs_vec) {
obj_rec& dir = get<0>(dirs_rec);
if (verbose) {
std::cout << "read back objects in "
<< dir.rgw_fh->full_object_name()
<< std::endl;
}
for (auto& sobj : get<1>(dirs_rec)) {
/* only the first 2 file objects have data */
if ((sobj.rgw_fh->object_name().find("sfile_0")
!= std::string::npos) ||
(sobj.rgw_fh->object_name().find("sfile_1")
!= std::string::npos)) {
ASSERT_TRUE(sobj.rgw_fh->is_file());
ASSERT_EQ(sobj.rgw_fh->get_size(), 16UL);
// do it
memset(buf, 0, 256);
if (verbose) {
std::cout << "reading 0,256 " << sobj.rgw_fh->relative_object_name()
<< std::endl;
}
rc = rgw_read(fs, sobj.fh, 0, 256, &nread, buf, RGW_READ_FLAG_NONE);
ASSERT_EQ(rc, 0);
if (verbose) {
std::cout << "\tread back from " << sobj.name
<< " : \"" << buf << "\""
<< std::endl;
}
}
}
}
}
}
TEST(LibRGW, READF_SETUP1)
{
struct stat st;
if (do_dirs1) {
if (do_create) {
if ((! stat(readf_out_name.c_str(), &st)) &&
(S_ISREG(st.st_mode)) &&
(st.st_size == 6291456))
return;
ofstream of;
of.open(readf_out_name, ios::out|ios::app|ios::binary);
for (int ix1 = 0; ix1 < 6; ++ix1) {
for (int ix2 = 0; ix2 < 1024*1024; ++ix2) {
of << ix1;
}
}
}
}
}
TEST(LibRGW, READF_DIRS1) {
if (do_dirs1) {
if (do_readf) {
obj_rec fobj{readf_name, nullptr, dirs1_b.fh, nullptr};
int rc = rgw_lookup(fs, dirs1_b.fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_NE(fobj.fh, nullptr);
fobj.sync();
ofstream of;
of.open(readf_out_name, ios::out|ios::app|ios::binary);
int bufsz = 1024 * 1024 * sizeof(char);
auto buffer = std::make_unique<char[]>(bufsz);
uint64_t offset = 0;
uint64_t length = bufsz;
for (int ix = 0; ix < 6; ++ix) {
size_t nread = 0;
memset(buffer.get(), 0, length); // XXX
rc = rgw_read(fs, fobj.fh, offset, length, &nread, buffer.get(),
RGW_READ_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nread, length);
of.write(buffer.get(), length);
offset += nread;
}
of.close();
rgw_fh_rele(fs, fobj.fh, 0 /* flags */);
}
}
}
TEST(LibRGW, WRITEF_DIRS1) {
if (do_dirs1) {
if (do_writef) {
int rc;
ifstream ifs;
ifs.open(readf_out_name, ios::out|ios::app|ios::binary);
ASSERT_TRUE(ifs.is_open());
obj_rec fobj{writef_name, nullptr, dirs1_b.fh, nullptr};
(void) rgw_lookup(fs, fobj.parent_fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! fobj.fh) {
if (do_create) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, fobj.parent_fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(fobj.fh, nullptr);
fobj.sync();
/* begin write transaction */
rc = rgw_open(fs, fobj.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(fobj.rgw_fh->is_open());
int bufsz = 1024 * 1024 * sizeof(char);
char *buffer = (char*) malloc(bufsz);
uint64_t offset = 0;
uint64_t length = bufsz;
for (int ix = 0; ix < 6; ++ix) {
ASSERT_TRUE(ifs.good());
ifs.read(buffer, bufsz);
size_t nwritten = 0;
string str;
str.assign(buffer, 4);
if (verbose) {
std::cout << "read and writing " << length << " bytes"
<< " from " << readf_out_name
<< " at offset " << offset
<< " (" << str << "... [first 4 chars])"
<< std::endl;
}
char* leakbuf = (char*) malloc(bufsz);
memcpy(leakbuf, buffer, length);
rc = rgw_write(fs, fobj.fh, offset, length, &nwritten, leakbuf,
RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nwritten, length);
offset += length;
}
/* commit write transaction */
rc = rgw_close(fs, fobj.fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ifs.close();
free(buffer);
rgw_fh_rele(fs, fobj.fh, 0 /* flags */);
}
}
}
TEST(LibRGW, RELEASE_DIRS1) {
if (do_dirs1) {
/* force release of handles for children of dirs1--force subsequent
* checks to reload them from the cluster.
*
* while doing this, verify handle cleanup and correct LRU state
* (not reachable)
*/
int rc;
for (auto& dirs_rec : dirs_vec) {
for (auto& obj : get<1>(dirs_rec)) {
if (verbose) {
std::cout << "release " << obj.name
<< " type: " << obj.rgw_fh->stype()
<< " refs: " << obj.rgw_fh->get_refcnt()
<< std::endl;
}
ASSERT_EQ(obj.rgw_fh->get_refcnt(), 2UL);
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_EQ(obj.rgw_fh->get_refcnt(), 1UL);
/* try-discard handle */
/* clear obj_rec vec */
}
}
}
}
extern "C" {
static int r1_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
struct rgw_file_handle* parent_fh
= static_cast<struct rgw_file_handle*>(arg);
RGWFileHandle* rgw_fh = get_rgwfh(parent_fh);
lsubdout(cct, rgw, 10) << __func__
<< " bucket=" << rgw_fh->bucket_name()
<< " dir=" << rgw_fh->full_object_name()
<< " called back name=" << name
<< " flags=" << flags
<< dendl;
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
obj_stack.push(
obj_rec{std::move(name_str), nullptr, parent_fh, nullptr});
}
return true; /* XXX */
}
}
TEST(LibRGW, HIER1) {
if (do_hier1) {
int rc;
obj_stack.push(
obj_rec{bucket_name, nullptr, nullptr, nullptr});
while (! obj_stack.empty()) {
auto& elt = obj_stack.top();
if (! elt.fh) {
struct rgw_file_handle* parent_fh = elt.parent_fh
? elt.parent_fh : fs->root_fh;
RGWFileHandle* pfh = get_rgwfh(parent_fh);
rgw::ignore(pfh);
lsubdout(cct, rgw, 10)
<< "rgw_lookup:"
<< " parent object_name()=" << pfh->object_name()
<< " parent full_object_name()=" << pfh->full_object_name()
<< " elt.name=" << elt.name
<< dendl;
rc = rgw_lookup(fs, parent_fh, elt.name.c_str(), &elt.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(rc, 0);
// XXXX
RGWFileHandle* efh = get_rgwfh(elt.fh);
rgw::ignore(efh);
lsubdout(cct, rgw, 10)
<< "rgw_lookup result:"
<< " elt object_name()=" << efh->object_name()
<< " elt full_object_name()=" << efh->full_object_name()
<< " elt.name=" << elt.name
<< dendl;
ASSERT_NE(elt.fh, nullptr);
elt.rgw_fh = get_rgwfh(elt.fh);
elt.parent_fh = elt.rgw_fh->get_parent()->get_fh();
ASSERT_EQ(elt.parent_fh, parent_fh);
continue;
} else {
// we have a handle in some state in top position
switch(elt.fh->fh_type) {
case RGW_FS_TYPE_DIRECTORY:
if (! elt.state.readdir) {
// descending
uint64_t offset = 0;
bool eof; // XXX
lsubdout(cct, rgw, 10)
<< "readdir in"
<< " bucket: " << elt.rgw_fh->bucket_name()
<< " object_name: " << elt.rgw_fh->object_name()
<< " full_name: " << elt.rgw_fh->full_object_name()
<< dendl;
rc = rgw_readdir(fs, elt.fh, &offset, r1_cb, elt.fh, &eof,
RGW_READDIR_FLAG_DOTDOT);
elt.state.readdir = true;
ASSERT_EQ(rc, 0);
// ASSERT_TRUE(eof); // XXXX working incorrectly w/single readdir
} else {
// ascending
std::cout << elt << std::endl;
cleanup_queue.push_back(elt);
obj_stack.pop();
}
break;
case RGW_FS_TYPE_FILE:
// ascending
std::cout << elt << std::endl;
cleanup_queue.push_back(elt);
obj_stack.pop();
break;
default:
ceph_abort();
};
}
}
}
}
TEST(LibRGW, MARKER1_SETUP_BUCKET) {
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_marker1) {
struct stat st;
int ret;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
if (do_create) {
ret = rgw_mkdir(fs, bucket_fh, marker_dir.c_str(), &st, create_mask,
&marker_fh, RGW_MKDIR_FLAG_NONE);
} else {
ret = rgw_lookup(fs, bucket_fh, marker_dir.c_str(), &marker_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
}
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, MARKER1_SETUP_OBJECTS)
{
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_marker1 && do_create) {
int ret;
for (int ix = 0; ix < marker_nobjs; ++ix) {
std::string object_name("f_");
object_name += to_string(ix);
obj_rec obj{object_name, nullptr, marker_fh, nullptr};
// lookup object--all operations are by handle
ret = rgw_lookup(fs, marker_fh, obj.name.c_str(), &obj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
obj.rgw_fh = get_rgwfh(obj.fh);
// open object--open transaction
ret = rgw_open(fs, obj.fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_TRUE(obj.rgw_fh->is_open());
// unstable write data
size_t nbytes;
string data("data for ");
data += object_name;
int ret = rgw_write(fs, obj.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
// commit transaction (write on close)
ret = rgw_close(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
// save for cleanup
marker_objs.push_back(obj);
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
dirent_vec& dvec =
*(static_cast<dirent_vec*>(arg));
lsubdout(cct, rgw, 10) << __func__
<< " bucket=" << bucket_name
<< " dir=" << marker_dir
<< " iv count=" << dvec.count
<< " called back name=" << name
<< " flags=" << flags
<< dendl;
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
dvec.obj_names.push_back(dirent_t{std::move(name_str), offset});
}
return true; /* XXX */
}
}
TEST(LibRGW, MARKER1_READDIR)
{
if (do_marker1) {
using std::get;
dirent_vec dvec;
uint64_t offset = 0;
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir(fs, marker_fh, &offset, r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_DOTDOT);
ASSERT_EQ(ret, 0);
ASSERT_EQ(offset, get<1>(dvec.obj_names.back())); // cookie check
++dvec.count;
} while(!eof);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER1_OBJ_CLEANUP)
{
int rc;
for (auto& obj : marker_objs) {
if (obj.fh) {
if (do_delete) {
if (verbose) {
std::cout << "unlinking: " << bucket_name << ":" << obj.name
<< std::endl;
}
rc = rgw_unlink(fs, marker_fh, obj.name.c_str(), RGW_UNLINK_FLAG_NONE);
}
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
marker_objs.clear();
}
TEST(LibRGW, CLEANUP) {
int rc;
if (do_marker1) {
cleanup_queue.push_back(
obj_rec{bucket_name, bucket_fh, fs->root_fh, get_rgwfh(fs->root_fh)});
}
for (auto& elt : cleanup_queue) {
if (elt.fh) {
rc = rgw_fh_rele(fs, elt.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
cleanup_queue.clear();
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--hier1",
(char*) nullptr)) {
do_hier1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--dirs1",
(char*) nullptr)) {
do_dirs1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--marker1",
(char*) nullptr)) {
do_marker1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--setattr",
(char*) nullptr)) {
do_setattr = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--rename",
(char*) nullptr)) {
do_rename = true;
} else if (ceph_argparse_flag(args, arg_iter, "--readf",
(char*) nullptr)) {
do_readf = true;
} else if (ceph_argparse_flag(args, arg_iter, "--writef",
(char*) nullptr)) {
do_writef = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 32,378 | 25.649383 | 78 |
cc
|
null |
ceph-main/src/test/librgw_file_xattr.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include <boost/algorithm/string.hpp>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/errno.h"
#include "common/debug.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
using namespace rgw;
string uid("testuser");
string access_key("");
string secret_key("");
librgw_t rgw_h = nullptr;
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name{"v4recov"};
string object_path{"node0/clientids"};
string key1{"black"};
string val1{"metallic"};
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
[[maybe_unused]] ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
typedef std::vector<obj_rec> obj_vec;
obj_vec ovec;
bool do_stat = false;
bool do_create = false;
bool do_delete = false;
bool do_hexdump = false;
bool verbose = false;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount(rgw_h, uid.c_str(), access_key.c_str(),
secret_key.c_str(), &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, CREATE_BUCKET) {
if ((! bucket_fh) && do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CREATE_PATH) {
if (!bucket_fh)
return;
vector<string> segs;
boost::split(segs, object_path, boost::is_any_of("/"));
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ix, ret, sz = segs.size();
for (ix = 0; ix < sz; ++ix) {
auto& seg = segs[ix];
struct rgw_file_handle* parent_fh = (ix > 0) ? ovec[ix-1].fh : bucket_fh;
obj_rec dir{seg, nullptr, parent_fh, nullptr};
if (do_create) {
ret = rgw_mkdir(fs, dir.parent_fh, dir.name.c_str(), &st, create_mask,
&dir.fh, RGW_MKDIR_FLAG_NONE);
} else {
ret = rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
}
ASSERT_EQ(ret, 0);
dir.sync();
ovec.push_back(dir);
if (verbose) {
std::cout << "create: " << dir.name << std::endl;
}
}
}
TEST(LibRGW, CHECK_PATH_REFS) {
if (!bucket_fh)
return;
int ix, sz = ovec.size();
for (ix = 0; ix < sz; ++ix) {
auto& dir = ovec[ix];
if (verbose) {
std::cout << "name: " << dir.name
<< " refcnt: " << dir.rgw_fh->get_refcnt()
<< std::endl;
}
if (ix == 0) {
// sentinel, +1 parent, +1 path
ASSERT_EQ(dir.rgw_fh->get_refcnt(), 3U);
}
if (ix == 1) {
// sentinel, +1 path
ASSERT_EQ(dir.rgw_fh->get_refcnt(), 2U);
}
}
}
TEST(LibRGW, SETXATTR1) {
if (!bucket_fh)
return;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k = { const_cast<char*>(key1.c_str()),
uint32_t(key1.length()) };
rgw_xattrstr xattr_v = { const_cast<char*>(val1.c_str()),
uint32_t(val1.length()) };
rgw_xattr xattr = { xattr_k, xattr_v };
rgw_xattrlist xattrlist = { &xattr, 1 };
int ret = rgw_setxattrs(fs, dir.fh, &xattrlist, RGW_SETXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
extern "C" {
static int getattr_cb(rgw_xattrlist *attrs, void *arg, uint32_t flags)
{
auto& attrmap =
*(static_cast<std::map<std::string, std::string>*>(arg));
for (uint32_t ix = 0; ix < attrs->xattr_cnt; ++ix) {
auto& xattr = attrs->xattrs[ix];
string k{xattr.key.val, xattr.key.len};
string v{xattr.val.val, xattr.val.len};
if (verbose) {
std::cout << __func__
<< " attr k: " << k << " v: " << v
<< std::endl;
}
attrmap.insert(std::map<std::string, std::string>::value_type(k, v));
}
return 0;
}
}
TEST(LibRGW, GETXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k1 =
{const_cast<char*>(key1.c_str()), uint32_t(key1.length())};
rgw_xattrstr xattr_v1 = {nullptr, 0};
std::string key2 = "user.rgw.etag";
rgw_xattrstr xattr_k2 =
{const_cast<char*>(key2.c_str()), uint32_t(key2.length())};
rgw_xattrstr xattr_v2 = {nullptr, 0};
rgw_xattr xattrs[2] = {{xattr_k1, xattr_v1},
{xattr_k2, xattr_v2}};
/* XXX gcc won't accept static_cast here, don't see why */
rgw_xattrlist xattrlist = {reinterpret_cast<rgw_xattr*>(&xattrs), 2};
std::map<std::string, std::string> out_attrmap;
int ret = rgw_getxattrs(fs, dir.fh, &xattrlist, getattr_cb, &out_attrmap,
RGW_GETXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
/* check our user attr */
ASSERT_TRUE(out_attrmap.find(key1) != out_attrmap.end());
}
TEST(LibRGW, LSXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr filter_prefix = { nullptr, 0}; // XXX ignored, for now
std::map<std::string, std::string> out_attrmap;
int ret = rgw_lsxattrs(fs, dir.fh, &filter_prefix, getattr_cb,
&out_attrmap, RGW_LSXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
}
TEST(LibRGW, RMXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k = { const_cast<char*>(key1.c_str()),
uint32_t(key1.length()) };
rgw_xattrstr xattr_v = { nullptr, 0 };
rgw_xattr xattr = { xattr_k, xattr_v };
rgw_xattrlist xattrlist = { &xattr, 1 };
int ret = rgw_rmxattrs(fs, dir.fh, &xattrlist, RGW_RMXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LSXATTR2) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr filter_prefix = { nullptr, 0 }; // XXX ignored, for now
std::map<std::string, std::string> out_attrmap;
int ret = rgw_lsxattrs(fs, dir.fh, &filter_prefix, getattr_cb,
&out_attrmap, RGW_LSXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
/* verify deletion */
ASSERT_TRUE(out_attrmap.find(key1) == out_attrmap.end());
}
TEST(LibRGW, CLEANUP) {
int ret = 0;
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
if (bucket_fh) {
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
}
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_flag(args, arg_iter, "--stat",
(char*) nullptr)) {
do_stat = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* dont accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 10,598 | 23.421659 | 79 |
cc
|
null |
ceph-main/src/test/mime.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/mime.h"
#include "gtest/gtest.h"
#include <stdint.h>
#include <string>
using std::string;
TEST(MimeTests, SimpleEncode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_encode_as_qp("abc", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_encode_as_qp("abc", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("abc"), string(output));
len = mime_encode_as_qp("a=b", NULL, 0);
ASSERT_EQ(len, 6);
len = mime_encode_as_qp("a=b", output, 6);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a=3Db"), string(output));
len = mime_encode_as_qp("Libert\xc3\xa9", NULL, 0);
ASSERT_EQ(len, 13);
len = mime_encode_as_qp("Libert\xc3\xa9", output, 13);
ASSERT_EQ(len, 13);
ASSERT_EQ(string("Libert=C3=A9"), string(output));
}
TEST(MimeTests, EncodeOutOfSpace) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_encode_as_qp("abcdefg", NULL, 0);
ASSERT_EQ(len, 8);
len = mime_encode_as_qp("abcdefg", output, 4);
ASSERT_EQ(len, 8);
ASSERT_EQ(string("abc"), string(output));
len = mime_encode_as_qp("abcdefg", output, 1);
ASSERT_EQ(len, 8);
ASSERT_EQ(string(""), string(output));
len = mime_encode_as_qp("a=b", output, 2);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a"), string(output));
len = mime_encode_as_qp("a=b", output, 3);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a"), string(output));
}
TEST(MimeTests, SimpleDecode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("abc", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_decode_from_qp("abc", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("abc"), string(output));
len = mime_decode_from_qp("a=3Db", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_decode_from_qp("a=3Db", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a=b"), string(output));
len = mime_decode_from_qp("Libert=C3=A9", NULL, 0);
ASSERT_EQ(len, 9);
len = mime_decode_from_qp("Libert=C3=A9", output, 9);
ASSERT_EQ(len, 9);
ASSERT_EQ(string("Libert\xc3\xa9"), string(output));
}
TEST(MimeTests, LowercaseDecode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("Libert=c3=a9", NULL, 0);
ASSERT_EQ(len, 9);
len = mime_decode_from_qp("Libert=c3=a9", output, 9);
ASSERT_EQ(len, 9);
ASSERT_EQ(string("Libert\xc3\xa9"), string(output));
}
TEST(MimeTests, DecodeOutOfSpace) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("abcdefg", NULL, 0);
ASSERT_EQ(len, 8);
len = mime_decode_from_qp("abcdefg", output, 4);
ASSERT_EQ(len, 8);
ASSERT_EQ(string("abc"), string(output));
len = mime_decode_from_qp("abcdefg", output, 1);
ASSERT_EQ(len, 8);
ASSERT_EQ(string(""), string(output));
len = mime_decode_from_qp("a=3Db", output, 2);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a"), string(output));
len = mime_decode_from_qp("a=3Db", output, 3);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a="), string(output));
}
TEST(MimeTests, DecodeErrors) {
char output[128];
memset(output, 0, sizeof(output));
int len;
// incomplete escape sequence
len = mime_decode_from_qp("boo=", output, sizeof(output));
ASSERT_LT(len, 0);
// invalid escape sequences
len = mime_decode_from_qp("boo=gg", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo=g", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo==", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo=44bar=z", output, sizeof(output));
ASSERT_LT(len, 0);
// high bit should not be set in quoted-printable mime output
unsigned char bad_input2[] = { 0x81, 0x6a, 0x0 };
len = mime_decode_from_qp(reinterpret_cast<const char*>(bad_input2),
output, sizeof(output));
ASSERT_LT(len, 0);
}
| 4,248 | 27.139073 | 70 |
cc
|
null |
ceph-main/src/test/multi_stress_watch.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include "include/rados/librados.h"
#include "include/rados/librados.hpp"
#include "test/librados/test_cxx.h"
#include <errno.h>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <map>
#include <iostream>
#include <string>
#include <stdlib.h>
#include <unistd.h>
using namespace librados;
using std::map;
using std::string;
class WatchNotifyTestCtx : public WatchCtx
{
public:
WatchNotifyTestCtx(std::mutex &lock)
: lock{lock} {}
void notify(uint8_t opcode, uint64_t ver, bufferlist &bl) override {
std::unique_lock locker {lock};
notified = true;
cond.notify_one();
}
bool wait() {
std::unique_lock locker {lock};
return cond.wait_for(locker, std::chrono::seconds(1200),
[this] { return notified; });
}
private:
bool notified = false;
std::mutex& lock;
std::condition_variable cond;
};
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
void
test_loop(Rados &cluster, std::string pool_name, std::string obj_name)
{
int ret;
IoCtx ioctx;
ret = cluster.ioctx_create(pool_name.c_str(), ioctx);
if (ret < 0) {
std::cerr << "ioctx_create " << pool_name << " failed with " << ret << std::endl;
exit(1);
}
ioctx.application_enable("rados", true);
ret = ioctx.create(obj_name, false);
if (ret < 0) {
std::cerr << "create failed with " << ret << std::endl;
exit(1);
}
std::mutex lock;
constexpr int NR_ITERATIONS = 10000;
for (int i = 0; i < NR_ITERATIONS; ++i) {
std::cout << "Iteration " << i << std::endl;
uint64_t handle;
WatchNotifyTestCtx ctx{lock};
ret = ioctx.watch(obj_name, 0, &handle, &ctx);
ceph_assert(!ret);
bufferlist bl2;
ret = ioctx.notify(obj_name, 0, bl2);
ceph_assert(!ret);
ceph_assert_always(ctx.wait());
ioctx.unwatch(obj_name, handle);
}
ioctx.close();
ret = cluster.pool_delete(pool_name.c_str());
if (ret < 0) {
std::cerr << "pool_delete failed with " << ret << std::endl;
exit(1);
}
}
#pragma GCC diagnostic pop
#pragma GCC diagnostic warning "-Wpragmas"
void
test_replicated(Rados &cluster, std::string pool_name, const std::string &obj_name)
{
// May already exist
cluster.pool_create(pool_name.c_str());
test_loop(cluster, pool_name, obj_name);
}
void
test_erasure(Rados &cluster, const std::string &pool_name, const std::string &obj_name)
{
string outs;
bufferlist inbl;
int ret;
ret = cluster.mon_command(
"{\"prefix\": \"osd erasure-code-profile set\", \"name\": \"testprofile\", \"profile\": [ \"k=2\", \"m=1\", \"crush-failure-domain=osd\"]}",
inbl, NULL, &outs);
if (ret < 0) {
std::cerr << "mon_command erasure-code-profile set failed with " << ret << std::endl;
exit(1);
}
//std::cout << outs << std::endl;
outs.clear();
ret = cluster.mon_command(
"{\"prefix\": \"osd pool create\", \"pool\": \"" + pool_name + "\", \"pool_type\":\"erasure\", \"pg_num\":12, \"pgp_num\":12, \"erasure_code_profile\":\"testprofile\"}",
inbl, NULL, &outs);
if (ret < 0) {
std::cerr << outs << std::endl;
std::cerr << "mon_command create pool failed with " << ret << std::endl;
exit(1);
}
//std::cout << outs << std::endl;
cluster.wait_for_latest_osdmap();
test_loop(cluster, pool_name, obj_name);
return;
}
int main(int args, char **argv)
{
if (args != 3 && args != 4) {
std::cerr << "Error: " << argv[0] << " [ec|rep] pool_name obj_name" << std::endl;
return 1;
}
std::string pool_name, obj_name, type;
// For backward compatibility with unmodified teuthology version
if (args == 3) {
type = "rep";
pool_name = argv[1];
obj_name = argv[2];
} else {
type = argv[1];
pool_name = argv[2];
obj_name = argv[3];
}
std::cout << "Test type " << type << std::endl;
std::cout << "pool_name, obj_name are " << pool_name << ", " << obj_name << std::endl;
if (type != "ec" && type != "rep") {
std::cerr << "Error: " << argv[0] << " Invalid arg must be 'ec' or 'rep' saw " << type << std::endl;
return 1;
}
Rados cluster;
std::string err = connect_cluster_pp(cluster);
if (err.length()) {
std::cerr << "Error " << err << std::endl;
return 1;
}
if (type == "rep")
test_replicated(cluster, pool_name, obj_name);
else if (type == "ec")
test_erasure(cluster, pool_name, obj_name);
return 0;
}
| 4,493 | 25.435294 | 173 |
cc
|
null |
ceph-main/src/test/objectstore_bench.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <chrono>
#include <cassert>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
#include "os/ObjectStore.h"
#include "global/global_init.h"
#include "common/strtol.h"
#include "common/ceph_argparse.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_filestore
using namespace std;
static void usage()
{
cout << "usage: ceph_objectstore_bench [flags]\n"
" --size\n"
" total size in bytes\n"
" --block-size\n"
" block size in bytes for each write\n"
" --repeats\n"
" number of times to repeat the write cycle\n"
" --threads\n"
" number of threads to carry out this workload\n"
" --multi-object\n"
" have each thread write to a separate object\n" << std::endl;
generic_server_usage();
}
// helper class for bytes with units
struct byte_units {
size_t v;
// cppcheck-suppress noExplicitConstructor
byte_units(size_t v) : v(v) {}
bool parse(const std::string &val, std::string *err);
operator size_t() const { return v; }
};
bool byte_units::parse(const std::string &val, std::string *err)
{
v = strict_iecstrtoll(val, err);
return err->empty();
}
std::ostream& operator<<(std::ostream &out, const byte_units &amount)
{
static const char* units[] = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
static const int max_units = sizeof(units)/sizeof(*units);
int unit = 0;
auto v = amount.v;
while (v >= 1024 && unit < max_units) {
// preserve significant bytes
if (v < 1048576 && (v % 1024 != 0))
break;
v >>= 10;
unit++;
}
return out << v << ' ' << units[unit];
}
struct Config {
byte_units size;
byte_units block_size;
int repeats;
int threads;
bool multi_object;
Config()
: size(1048576), block_size(4096),
repeats(1), threads(1),
multi_object(false) {}
};
class C_NotifyCond : public Context {
std::mutex *mutex;
std::condition_variable *cond;
bool *done;
public:
C_NotifyCond(std::mutex *mutex, std::condition_variable *cond, bool *done)
: mutex(mutex), cond(cond), done(done) {}
void finish(int r) override {
std::lock_guard<std::mutex> lock(*mutex);
*done = true;
cond->notify_one();
}
};
void osbench_worker(ObjectStore *os, const Config &cfg,
const coll_t cid, const ghobject_t oid,
uint64_t starting_offset)
{
bufferlist data;
data.append(buffer::create(cfg.block_size));
dout(0) << "Writing " << cfg.size
<< " in blocks of " << cfg.block_size << dendl;
ceph_assert(starting_offset < cfg.size);
ceph_assert(starting_offset % cfg.block_size == 0);
ObjectStore::CollectionHandle ch = os->open_collection(cid);
ceph_assert(ch);
for (int i = 0; i < cfg.repeats; ++i) {
uint64_t offset = starting_offset;
size_t len = cfg.size;
vector<ObjectStore::Transaction> tls;
std::cout << "Write cycle " << i << std::endl;
while (len) {
size_t count = len < cfg.block_size ? len : (size_t)cfg.block_size;
auto t = new ObjectStore::Transaction;
t->write(cid, oid, offset, count, data);
tls.push_back(std::move(*t));
delete t;
offset += count;
if (offset > cfg.size)
offset -= cfg.size;
len -= count;
}
// set up the finisher
std::mutex mutex;
std::condition_variable cond;
bool done = false;
tls.back().register_on_commit(new C_NotifyCond(&mutex, &cond, &done));
os->queue_transactions(ch, tls);
std::unique_lock<std::mutex> lock(mutex);
cond.wait(lock, [&done](){ return done; });
lock.unlock();
}
}
int main(int argc, const char *argv[])
{
// command-line arguments
auto args = argv_to_vec(argc, argv);
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage();
exit(0);
}
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
Config cfg;
std::string val;
vector<const char*>::iterator i = args.begin();
while (i != args.end()) {
if (ceph_argparse_double_dash(args, i))
break;
if (ceph_argparse_witharg(args, i, &val, "--size", (char*)nullptr)) {
std::string err;
if (!cfg.size.parse(val, &err)) {
derr << "error parsing size: " << err << dendl;
exit(1);
}
} else if (ceph_argparse_witharg(args, i, &val, "--block-size", (char*)nullptr)) {
std::string err;
if (!cfg.block_size.parse(val, &err)) {
derr << "error parsing block-size: " << err << dendl;
exit(1);
}
} else if (ceph_argparse_witharg(args, i, &val, "--repeats", (char*)nullptr)) {
cfg.repeats = atoi(val.c_str());
} else if (ceph_argparse_witharg(args, i, &val, "--threads", (char*)nullptr)) {
cfg.threads = atoi(val.c_str());
} else if (ceph_argparse_flag(args, i, "--multi-object", (char*)nullptr)) {
cfg.multi_object = true;
} else {
derr << "Error: can't understand argument: " << *i << "\n" << dendl;
exit(1);
}
}
common_init_finish(g_ceph_context);
// create object store
dout(0) << "objectstore " << g_conf()->osd_objectstore << dendl;
dout(0) << "data " << g_conf()->osd_data << dendl;
dout(0) << "journal " << g_conf()->osd_journal << dendl;
dout(0) << "size " << cfg.size << dendl;
dout(0) << "block-size " << cfg.block_size << dendl;
dout(0) << "repeats " << cfg.repeats << dendl;
dout(0) << "threads " << cfg.threads << dendl;
auto os =
ObjectStore::create(g_ceph_context,
g_conf()->osd_objectstore,
g_conf()->osd_data,
g_conf()->osd_journal);
//Checking data folder: create if needed or error if it's not empty
DIR *dir = ::opendir(g_conf()->osd_data.c_str());
if (!dir) {
std::string cmd("mkdir -p ");
cmd+=g_conf()->osd_data;
int r = ::system( cmd.c_str() );
if( r<0 ){
derr << "Failed to create data directory, ret = " << r << dendl;
return 1;
}
}
else {
bool non_empty = readdir(dir) != NULL && readdir(dir) != NULL && readdir(dir) != NULL;
if( non_empty ){
derr << "Data directory '"<<g_conf()->osd_data<<"' isn't empty, please clean it first."<< dendl;
return 1;
}
}
::closedir(dir);
//Create folders for journal if needed
string journal_base = g_conf()->osd_journal.substr(0, g_conf()->osd_journal.rfind('/'));
struct stat sb;
if (stat(journal_base.c_str(), &sb) != 0 ){
std::string cmd("mkdir -p ");
cmd+=journal_base;
int r = ::system( cmd.c_str() );
if( r<0 ){
derr << "Failed to create journal directory, ret = " << r << dendl;
return 1;
}
}
if (!os) {
derr << "bad objectstore type " << g_conf()->osd_objectstore << dendl;
return 1;
}
if (os->mkfs() < 0) {
derr << "mkfs failed" << dendl;
return 1;
}
if (os->mount() < 0) {
derr << "mount failed" << dendl;
return 1;
}
dout(10) << "created objectstore " << os.get() << dendl;
// create a collection
spg_t pg;
const coll_t cid(pg);
ObjectStore::CollectionHandle ch = os->create_new_collection(cid);
{
ObjectStore::Transaction t;
t.create_collection(cid, 0);
os->queue_transaction(ch, std::move(t));
}
// create the objects
std::vector<ghobject_t> oids;
if (cfg.multi_object) {
oids.reserve(cfg.threads);
for (int i = 0; i < cfg.threads; i++) {
std::stringstream oss;
oss << "osbench-thread-" << i;
oids.emplace_back(hobject_t(sobject_t(oss.str(), CEPH_NOSNAP)));
ObjectStore::Transaction t;
t.touch(cid, oids[i]);
int r = os->queue_transaction(ch, std::move(t));
ceph_assert(r == 0);
}
} else {
oids.emplace_back(hobject_t(sobject_t("osbench", CEPH_NOSNAP)));
ObjectStore::Transaction t;
t.touch(cid, oids.back());
int r = os->queue_transaction(ch, std::move(t));
ceph_assert(r == 0);
}
// run the worker threads
std::vector<std::thread> workers;
workers.reserve(cfg.threads);
using namespace std::chrono;
auto t1 = high_resolution_clock::now();
for (int i = 0; i < cfg.threads; i++) {
const auto &oid = cfg.multi_object ? oids[i] : oids[0];
workers.emplace_back(osbench_worker, os.get(), std::ref(cfg),
cid, oid, i * cfg.size / cfg.threads);
}
for (auto &worker : workers)
worker.join();
auto t2 = high_resolution_clock::now();
workers.clear();
auto duration = duration_cast<microseconds>(t2 - t1);
byte_units total = cfg.size * cfg.repeats * cfg.threads;
byte_units rate = (1000000LL * total) / duration.count();
size_t iops = (1000000LL * total / cfg.block_size) / duration.count();
dout(0) << "Wrote " << total << " in "
<< duration.count() << "us, at a rate of " << rate << "/s and "
<< iops << " iops" << dendl;
// remove the objects
ObjectStore::Transaction t;
for (const auto &oid : oids)
t.remove(cid, oid);
os->queue_transaction(ch, std::move(t));
os->umount();
return 0;
}
| 9,291 | 27.157576 | 103 |
cc
|
null |
ceph-main/src/test/omap_bench.cc
|
/*
* Generate latency statistics for a configurable number of write
* operations of configurable size.
*
* Created on: May 21, 2012
* Author: Eleanor Cawthon
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#include "include/rados/librados.hpp"
#include "include/Context.h"
#include "common/ceph_context.h"
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "include/utime.h"
#include "common/ceph_argparse.h"
#include "test/omap_bench.h"
#include <string>
#include <iostream>
#include <cassert>
#include <climits>
#include <cmath>
using namespace std;
using ceph::bufferlist;
int OmapBench::setup(int argc, const char** argv) {
//parse key_value_store_bench args
auto args = argv_to_vec(argc, argv);
for (unsigned i = 0; i < args.size(); i++) {
if(i < args.size() - 1) {
if (strcmp(args[i], "-t") == 0) {
threads = atoi(args[i+1]);
} else if (strcmp(args[i], "-o") == 0) {
objects = atoi(args[i+1]);
} else if (strcmp(args[i], "--entries") == 0) {
entries_per_omap = atoi(args[i+1]);
} else if (strcmp(args[i], "--keysize") == 0) {
key_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--valsize") == 0) {
value_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--inc") == 0) {
increment = atoi(args[i+1]);
} else if (strcmp(args[i], "--omaptype") == 0) {
if(strcmp("rand",args[i+1]) == 0) {
omap_generator = OmapBench::generate_non_uniform_omap;
}
else if (strcmp("uniform", args[i+1]) == 0) {
omap_generator = OmapBench::generate_uniform_omap;
}
} else if (strcmp(args[i], "--name") == 0) {
rados_id = args[i+1];
}
} else if (strcmp(args[i], "--help") == 0) {
cout << "\nUsage: ostorebench [options]\n"
<< "Generate latency statistics for a configurable number of "
<< "key value pair operations of\n"
<< "configurable size.\n\n"
<< "OPTIONS\n"
<< " -t number of threads to use (default "<<threads;
cout << ")\n"
<< " -o number of objects to write (default "<<objects;
cout << ")\n"
<< " --entries number of entries per (default "
<< entries_per_omap;
cout <<")\n"
<< " --keysize number of characters per key "
<< "(default "<<key_size;
cout << ")\n"
<< " --valsize number of characters per value "
<< "(default "<<value_size;
cout << ")\n"
<< " --inc specify the increment to use in the displayed "
<< "histogram (default "<<increment;
cout << ")\n"
<< " --omaptype specify how omaps should be generated - "
<< "rand for random sizes between\n"
<< " 0 and max size, uniform for all sizes"
<< " to be specified size.\n"
<< " (default uniform)\n";
cout << " --name the rados id to use (default "<< rados_id
<< ")\n";
exit(1);
}
}
int r = rados.init(rados_id.c_str());
if (r < 0) {
cout << "error during init" << std::endl;
return r;
}
r = rados.conf_parse_argv(argc, argv);
if (r < 0) {
cout << "error during parsing args" << std::endl;
return r;
}
r = rados.conf_parse_env(NULL);
if (r < 0) {
cout << "error during parsing env" << std::endl;
return r;
}
r = rados.conf_read_file(NULL);
if (r < 0) {
cout << "error during read file" << std::endl;
return r;
}
r = rados.connect();
if (r < 0) {
cout << "error during connect" << std::endl;
return r;
}
r = rados.ioctx_create(pool_name.c_str(), io_ctx);
if (r < 0) {
cout << "error creating io ctx" << std::endl;
rados.shutdown();
return r;
}
return 0;
}
//Writer functions
Writer::Writer(OmapBench *omap_bench) : ob(omap_bench) {
stringstream name;
ob->data_lock.lock();
name << omap_bench->prefix << ++(ob->data.started_ops);
ob->data_lock.unlock();
oid = name.str();
}
void Writer::start_time() {
begin_time = ceph_clock_now();
}
void Writer::stop_time() {
end_time = ceph_clock_now();
}
double Writer::get_time() {
return (end_time - begin_time) * 1000;
}
string Writer::get_oid() {
return oid;
}
std::map<std::string, bufferlist> & Writer::get_omap() {
return omap;
}
//AioWriter functions
AioWriter::AioWriter(OmapBench *ob) : Writer(ob) {
aioc = NULL;
}
AioWriter::~AioWriter() {
if(aioc) aioc->release();
}
librados::AioCompletion * AioWriter::get_aioc() {
return aioc;
}
void AioWriter::set_aioc(librados::callback_t complete) {
aioc = ob->rados.aio_create_completion(this, complete);
}
//Helper methods
void OmapBench::aio_is_complete(rados_completion_t c, void *arg) {
AioWriter *aiow = reinterpret_cast<AioWriter *>(arg);
aiow->stop_time();
ceph::mutex * data_lock = &aiow->ob->data_lock;
ceph::mutex * thread_is_free_lock = &aiow->ob->thread_is_free_lock;
ceph::condition_variable* thread_is_free = &aiow->ob->thread_is_free;
int &busythreads_count = aiow->ob->busythreads_count;
o_bench_data &data = aiow->ob->data;
int INCREMENT = aiow->ob->increment;
int err = aiow->get_aioc()->get_return_value();
if (err < 0) {
cout << "error writing AioCompletion";
return;
}
double time = aiow->get_time();
delete aiow;
data_lock->lock();
data.avg_latency = (data.avg_latency * data.completed_ops + time)
/ (data.completed_ops + 1);
data.completed_ops++;
if (time < data.min_latency) {
data.min_latency = time;
}
if (time > data.max_latency) {
data.max_latency = time;
}
data.total_latency += time;
++(data.freq_map[time / INCREMENT]);
if(data.freq_map[time/INCREMENT] > data.mode.second) {
data.mode.first = time/INCREMENT;
data.mode.second = data.freq_map[time/INCREMENT];
}
data_lock->unlock();
thread_is_free_lock->lock();
busythreads_count--;
thread_is_free->notify_all();
thread_is_free_lock->unlock();
}
string OmapBench::random_string(int len) {
string ret;
string alphanum = "0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < len; ++i) {
ret.push_back(alphanum[rand() % (alphanum.size() - 1)]);
}
return ret;
}
int OmapBench::run() {
return (((OmapBench *)this)->*OmapBench::test)(omap_generator);
}
int OmapBench::print_written_omap() {
for (int i = 1; i <= objects; i++) {
int err = 0;
librados::ObjectReadOperation key_read;
set<string> out_keys;
map<string, bufferlist> out_vals;
std::stringstream objstrm;
objstrm << prefix;
objstrm << i;
cout << "\nPrinting omap for "<<objstrm.str() << std::endl;
// FIXME: we ignore pmore here. this shouldn't happen for benchmark
// keys, though, unless the OSD limit is *really* low.
key_read.omap_get_keys2("", LONG_MAX, &out_keys, nullptr, &err);
io_ctx.operate(objstrm.str(), &key_read, NULL);
if (err < 0) {
cout << "error " << err;
cout << " getting omap key set " << std::endl;
return err;
}
librados::ObjectReadOperation val_read;
val_read.omap_get_vals_by_keys(out_keys, &out_vals, &err);
if (err < 0) {
cout << "error " << err;
cout << " getting omap value set " << std::endl;
return err;
}
io_ctx.operate(objstrm.str(), &val_read, NULL);
for (set<string>::iterator iter = out_keys.begin();
iter != out_keys.end(); ++iter) {
cout << *iter << "\t" << (out_vals)[*iter] << std::endl;
}
}
return 0;
}
void OmapBench::print_results() {
cout << "========================================================";
cout << "\nNumber of kvmaps written:\t" << objects;
cout << "\nNumber of ops at once:\t" << threads;
cout << "\nEntries per kvmap:\t\t" << entries_per_omap;
cout << "\nCharacters per key:\t" << key_size;
cout << "\nCharacters per val:\t" << value_size;
cout << std::endl;
cout << std::endl;
cout << "Average latency:\t" << data.avg_latency;
cout << "ms\nMinimum latency:\t" << data.min_latency;
cout << "ms\nMaximum latency:\t" << data.max_latency;
cout << "ms\nMode latency:\t\t"<<"between "<<data.mode.first * increment;
cout << " and " <<data.mode.first * increment + increment;
cout << "ms\nTotal latency:\t\t" << data.total_latency;
cout << "ms"<<std::endl;
cout << std::endl;
cout << "Histogram:" << std::endl;
for(int i = floor(data.min_latency / increment); i <
ceil(data.max_latency / increment); i++) {
cout << ">= "<< i * increment;
cout << "ms";
int spaces;
if (i == 0) spaces = 4;
else spaces = 3 - floor(log10(i));
for (int j = 0; j < spaces; j++) {
cout << " ";
}
cout << "[";
for(int j = 0; j < ((data.freq_map)[i])*45/(data.mode.second); j++) {
cout << "*";
}
cout << std::endl;
}
cout << "\n========================================================"
<< std::endl;
}
int OmapBench::write_omap_asynchronously(AioWriter *aiow,
const std::map<std::string,bufferlist> &omap) {
librados::ObjectWriteOperation owo;
owo.create(false);
owo.omap_clear();
owo.omap_set(omap);
aiow->start_time();
int err = io_ctx.aio_operate(aiow->get_oid(), aiow->get_aioc(), &owo);
if (err < 0) {
cout << "writing omap failed with code "<<err;
cout << std::endl;
return err;
}
return 0;
}
//Omap Generators
int OmapBench::generate_uniform_omap(const int omap_entries, const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
//setup omap
for (int i = 0; i < omap_entries; i++) {
bufferlist omap_val;
omap_val.append(random_string(value_size));
string key = random_string(key_size);
(*out_omap)[key]= omap_val;
}
return 0;
}
int OmapBench::generate_non_uniform_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
int num_entries = rand() % omap_entries + 1;
int key_len = rand() % key_size +1;
int val_len = rand() % value_size +1;
//setup omap
for (int i = 0; i < num_entries; i++) {
bufferlist omap_val;
omap_val.append(random_string(val_len));
string key = random_string(key_len);
(*out_omap)[key] = omap_val;
}
return 0;
}
int OmapBench::generate_small_non_random_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
stringstream key;
//setup omap
for (int i = 0; i < omap_entries; i++) {
bufferlist omap_val;
omap_val.append("Value ");
omap_val.append(i);
key << "Key " << i;
(*out_omap)[key.str()]= omap_val;
}
return 0;
}
//tests
int OmapBench::test_write_objects_in_parallel(omap_generator_t omap_gen) {
AioWriter *this_aio_writer;
std::unique_lock l{thread_is_free_lock};
for (int i = 0; i < objects; i++) {
ceph_assert(busythreads_count <= threads);
//wait for a writer to be free
if (busythreads_count == threads) {
thread_is_free.wait(l);
ceph_assert(busythreads_count < threads);
}
//set up the write
this_aio_writer = new AioWriter(this);
this_aio_writer->set_aioc(comp);
//perform the write
busythreads_count++;
int err = omap_gen(entries_per_omap, key_size, value_size,
& this_aio_writer->get_omap());
if (err < 0) {
return err;
}
err = OmapBench::write_omap_asynchronously(this_aio_writer,
(this_aio_writer->get_omap()));
if (err < 0) {
return err;
}
}
thread_is_free.wait(l, [this] { return busythreads_count <= 0;});
return 0;
}
/**
* runs the specified test with the specified parameters and generates
* a histogram of latencies
*/
int main(int argc, const char** argv) {
OmapBench ob;
int err = ob.setup(argc, argv);
if (err<0) {
cout << "error during setup: "<<err;
cout << std::endl;
exit(1);
}
err = ob.run();
if (err < 0) {
cout << "writing objects failed with code " << err;
cout << std::endl;
return err;
}
ob.print_results();
//uncomment to show omaps
/*err = ob.return print_written_omap();
if (err < 0) {
cout << "printing omaps failed with code " << err;
cout << std::endl;
return err;
}
*/
return 0;
}
| 12,407 | 27.722222 | 80 |
cc
|
null |
ceph-main/src/test/omap_bench.h
|
/*
* Generate latency statistics for a configurable number of object map write
* operations of configurable size.
*
* Created on: May 21, 2012
* Author: Eleanor Cawthon
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#ifndef OMAP_BENCH_HPP_
#define OMAP_BENCH_HPP_
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "include/rados/librados.hpp"
#include <string>
#include <map>
#include <cfloat>
using ceph::bufferlist;
struct o_bench_data {
double avg_latency;
double min_latency;
double max_latency;
double total_latency;
int started_ops;
int completed_ops;
std::map<int,int> freq_map;
std::pair<int,int> mode;
o_bench_data()
: avg_latency(0.0), min_latency(DBL_MAX), max_latency(0.0),
total_latency(0.0),
started_ops(0), completed_ops(0)
{}
};
class OmapBench;
typedef int (*omap_generator_t)(const int omap_entries, const int key_size,
const int value_size,
std::map<std::string,bufferlist> *out_omap);
typedef int (OmapBench::*test_t)(omap_generator_t omap_gen);
class Writer{
protected:
std::string oid;
utime_t begin_time;
utime_t end_time;
std::map<std::string,bufferlist> omap;
OmapBench *ob;
friend class OmapBench;
public:
Writer(OmapBench *omap_bench);
virtual ~Writer(){};
virtual void start_time();
virtual void stop_time();
virtual double get_time();
virtual std::string get_oid();
virtual std::map<std::string,bufferlist> & get_omap();
};
class AioWriter : public Writer{
protected:
librados::AioCompletion * aioc;
friend class OmapBench;
public:
AioWriter(OmapBench *omap_bench);
~AioWriter() override;
virtual librados::AioCompletion * get_aioc();
virtual void set_aioc(librados::callback_t complete);
};
class OmapBench{
protected:
librados::IoCtx io_ctx;
librados::Rados rados;
struct o_bench_data data;
test_t test;
omap_generator_t omap_generator;
//aio things
ceph::condition_variable thread_is_free;
ceph::mutex thread_is_free_lock =
ceph::make_mutex("OmapBench::thread_is_free_lock");
ceph::mutex data_lock =
ceph::make_mutex("OmapBench::data_lock");
int busythreads_count;
librados::callback_t comp;
std::string pool_name;
std::string rados_id;
std::string prefix;
int threads;
int objects;
int entries_per_omap;
int key_size;
int value_size;
double increment;
friend class Writer;
friend class AioWriter;
public:
OmapBench()
: test(&OmapBench::test_write_objects_in_parallel),
omap_generator(generate_uniform_omap),
busythreads_count(0),
comp(aio_is_complete),
pool_name("rbd"),
rados_id("admin"),
prefix(rados_id+".obj."),
threads(3), objects(100), entries_per_omap(10), key_size(10),
value_size(100), increment(10)
{}
/**
* Parses command line args, initializes rados and ioctx
*/
int setup(int argc, const char** argv);
/**
* Callback for when an AioCompletion (called from an AioWriter)
* is complete. deletes the AioWriter that called it,
* Updates data, updates busythreads, and signals thread_is_free.
*
* @param c provided by aio_write - not used
* @param arg the AioWriter that contains this AioCompletion
*/
static void aio_is_complete(rados_completion_t c, void *arg);
/**
* Generates a random string len characters long
*/
static std::string random_string(int len);
/*
* runs the test specified by test using the omap generator specified by
* omap_generator
*
* @return error code
*/
int run();
/*
* Prints all keys and values for all omap entries for all objects
*/
int print_written_omap();
/*
* Displays relevant constants and the histogram generated through a test
*/
void print_results();
/**
* Writes an object with the specified AioWriter.
*
* @param aiow the AioWriter to write with
* @param omap the omap to write
* @post: an asynchronous omap_set is launched
*/
int write_omap_asynchronously(AioWriter *aiow,
const std::map<std::string,bufferlist> &map);
/**
* Generates an omap with omap_entries entries, each with keys key_size
* characters long and with string values value_size characters long.
*
* @param out_map pointer to the map to be created
* @return error code
*/
static int generate_uniform_omap(const int omap_entries, const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap);
/**
* The same as generate_uniform_omap except that string lengths are picked
* randomly between 1 and the int arguments
*/
static int generate_non_uniform_omap(const int omap_entries,
const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap);
static int generate_small_non_random_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap);
/*
* Uses aio_write to write omaps generated by omap_gen to OBJECTS objects
* using THREADS AioWriters at a time.
*
* @param omap_gen the method used to generate the omaps.
*/
int test_write_objects_in_parallel(omap_generator_t omap_gen);
};
#endif /* OMAP_BENCH_HPP_ */
| 5,375 | 24.971014 | 78 |
h
|
null |
ceph-main/src/test/on_exit.cc
|
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include "include/on_exit.h"
#include "include/ceph_assert.h"
#ifndef MAP_ANONYMOUS
# ifdef MAP_ANON
# define MAP_ANONYMOUS MAP_ANON
# else
// cppcheck-suppress preprocessorErrorDirective
# error "Don't know how to create anonymous mmap"
# endif
#endif
static int func_scope_val;
static void add(void *incp)
{
func_scope_val += *((int*)incp);
}
static void func_scope(void)
{
OnExitManager mgr;
int *inc_1 = (int*)malloc(sizeof(*inc_1));
*inc_1 = 5;
mgr.add_callback(add, inc_1);
int *inc_2 = (int*)malloc(sizeof(*inc_2));
*inc_2 = 3;
mgr.add_callback(add, inc_2);
}
// shared between processes
static int *shared_val;
#define MAIN_SCOPE_VAL 0x1111111
static OnExitManager main_scope_mgr;
static void main_scope_cb(void *val)
{
*shared_val = *((int*)val);
}
#define EXIT_FUNC_VAL 0x22222222
static OnExitManager exit_func_mgr;
static void exit_func_cb(void *val)
{
*shared_val = *((int*)val);
}
static void call_exit()
{
exit(3);
}
int main(int argc, char **argv)
{
// test basic function scope behavior
ceph_assert(func_scope_val == 0);
func_scope();
ceph_assert(func_scope_val == 8);
// shared mem for exit tests
shared_val = (int*)mmap(NULL, sizeof(int),
PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
ceph_assert(shared_val != MAP_FAILED);
// test normal exit returning from main
*shared_val = 0;
int pid = fork();
ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
ceph_assert(ret == pid); // should be our child
ceph_assert(status == 0);
ceph_assert(*shared_val == MAIN_SCOPE_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits by returning from main. The parent checks the value after the
// child exits via the memory map.
ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = MAIN_SCOPE_VAL;
main_scope_mgr.add_callback(main_scope_cb, new_val);
return 0;
}
// test exit via exit()
*shared_val = 0;
pid = fork();
ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
ceph_assert(ret == pid); // should be our child
ceph_assert(WEXITSTATUS(status) == 3);
ceph_assert(*shared_val == EXIT_FUNC_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits via exit().
ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = EXIT_FUNC_VAL;
exit_func_mgr.add_callback(exit_func_cb, new_val);
call_exit();
ceph_abort();
}
return 0;
}
| 2,748 | 22.698276 | 74 |
cc
|
null |
ceph-main/src/test/perf_counters.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/int_types.h"
#include "include/types.h" // FIXME: ordering shouldn't be important, but right
// now, this include has to come before the others.
#include "common/perf_counters_key.h"
#include "common/perf_counters_collection.h"
#include "common/admin_socket_client.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "common/errno.h"
#include "common/safe_io.h"
#include "common/code_environment.h"
#include "global/global_context.h"
#include "global/global_init.h"
#include "include/msgr.h" // for CEPH_ENTITY_TYPE_CLIENT
#include "gtest/gtest.h"
#include <errno.h>
#include <fcntl.h>
#include <map>
#include <poll.h>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <thread>
#include "common/common_init.h"
using namespace std;
int main(int argc, char **argv) {
map<string,string> defaults = {
{ "admin_socket", get_rand_socket_path() }
};
std::vector<const char*> args;
auto cct = global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE|
CINIT_FLAG_NO_CCT_PERF_COUNTERS);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
TEST(PerfCounters, SimpleTest) {
AdminSocketClient client(get_rand_socket_path());
std::string message;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\" }", &message));
ASSERT_EQ("{}\n", message);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"counter dump\" }", &message));
ASSERT_EQ("{}\n", message);
}
enum {
TEST_PERFCOUNTERS1_ELEMENT_FIRST = 200,
TEST_PERFCOUNTERS1_ELEMENT_1,
TEST_PERFCOUNTERS1_ELEMENT_2,
TEST_PERFCOUNTERS1_ELEMENT_3,
TEST_PERFCOUNTERS1_ELEMENT_LAST,
};
std::string sd(const char *c)
{
std::string ret(c);
std::string::size_type sz = ret.size();
for (std::string::size_type i = 0; i < sz; ++i) {
if (ret[i] == '\'') {
ret[i] = '\"';
}
}
return ret;
}
static PerfCounters* setup_test_perfcounters1(CephContext *cct)
{
PerfCountersBuilder bld(cct, "test_perfcounter_1",
TEST_PERFCOUNTERS1_ELEMENT_FIRST, TEST_PERFCOUNTERS1_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS1_ELEMENT_1, "element1");
bld.add_time(TEST_PERFCOUNTERS1_ELEMENT_2, "element2");
bld.add_time_avg(TEST_PERFCOUNTERS1_ELEMENT_3, "element3");
return bld.create_perf_counters();
}
TEST(PerfCounters, SinglePerfCounters) {
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
PerfCounters* fake_pf = setup_test_perfcounters1(g_ceph_context);
coll->add(fake_pf);
AdminSocketClient client(get_rand_socket_path());
std::string msg;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":0,"
"\"element2\":0.000000000,\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
fake_pf->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf->tset(TEST_PERFCOUNTERS1_ELEMENT_2, utime_t(0, 500000000));
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t(100, 0));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,"
"\"element2\":0.500000000,\"element3\":{\"avgcount\":1,\"sum\":100.000000000,\"avgtime\":100.000000000}}}"), msg);
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t());
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t(20,0));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,\"element2\":0.500000000,"
"\"element3\":{\"avgcount\":3,\"sum\":120.000000000,\"avgtime\":40.000000000}}}"), msg);
fake_pf->reset();
msg.clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,"
"\"element2\":0.000000000,\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
}
enum {
TEST_PERFCOUNTERS2_ELEMENT_FIRST = 400,
TEST_PERFCOUNTERS2_ELEMENT_FOO,
TEST_PERFCOUNTERS2_ELEMENT_BAR,
TEST_PERFCOUNTERS2_ELEMENT_LAST,
};
static PerfCounters* setup_test_perfcounter2(CephContext *cct)
{
PerfCountersBuilder bld(cct, "test_perfcounter_2",
TEST_PERFCOUNTERS2_ELEMENT_FIRST, TEST_PERFCOUNTERS2_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS2_ELEMENT_FOO, "foo");
bld.add_time(TEST_PERFCOUNTERS2_ELEMENT_BAR, "bar");
return bld.create_perf_counters();
}
TEST(PerfCounters, MultiplePerfCounters) {
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
coll->clear();
PerfCounters* fake_pf1 = setup_test_perfcounters1(g_ceph_context);
PerfCounters* fake_pf2 = setup_test_perfcounter2(g_ceph_context);
coll->add(fake_pf1);
coll->add(fake_pf2);
AdminSocketClient client(get_rand_socket_path());
std::string msg;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":0,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 5);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":6,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->reset(string("test_perfcounter_1"));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":6,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 6);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->reset(string("all"));
msg.clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->remove(fake_pf2);
delete fake_pf2;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,"
"\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf schema\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":{\"type\":2,\"metric_type\":\"gauge\",\"value_type\":\"integer\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"},\"element2\":{\"type\":1,\"metric_type\":\"gauge\",\"value_type\":\"real\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"},\"element3\":{\"type\":5,\"metric_type\":\"gauge\",\"value_type\":\"real-integer-pair\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"}}}"), msg);
coll->clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ("{}", msg);
}
TEST(PerfCounters, ResetPerfCounters) {
AdminSocketClient client(get_rand_socket_path());
std::string msg;
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
coll->clear();
PerfCounters* fake_pf1 = setup_test_perfcounters1(g_ceph_context);
coll->add(fake_pf1);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"all\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"success\":\"perf reset all\"}"), msg);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"test_perfcounter_1\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"success\":\"perf reset test_perfcounter_1\"}"), msg);
coll->clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"test_perfcounter_1\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"error\":\"Not find: test_perfcounter_1\"}"), msg);
}
enum {
TEST_PERFCOUNTERS3_ELEMENT_FIRST = 400,
TEST_PERFCOUNTERS3_ELEMENT_READ,
TEST_PERFCOUNTERS3_ELEMENT_LAST,
};
static std::shared_ptr<PerfCounters> setup_test_perfcounter3(CephContext* cct) {
PerfCountersBuilder bld(cct, "test_percounter_3",
TEST_PERFCOUNTERS3_ELEMENT_FIRST, TEST_PERFCOUNTERS3_ELEMENT_LAST);
bld.add_time_avg(TEST_PERFCOUNTERS3_ELEMENT_READ, "read_avg");
std::shared_ptr<PerfCounters> p(bld.create_perf_counters());
return p;
}
static void counters_inc_test(std::shared_ptr<PerfCounters> fake_pf) {
int i = 100000;
utime_t t;
// set to 1 nsec
t.set_from_double(0.000000001);
while (i--) {
// increase by one, make sure data.u64 equal to data.avgcount
fake_pf->tinc(TEST_PERFCOUNTERS3_ELEMENT_READ, t);
}
}
static void counters_readavg_test(std::shared_ptr<PerfCounters> fake_pf) {
int i = 100000;
while (i--) {
std::pair<uint64_t, uint64_t> dat = fake_pf->get_tavg_ns(TEST_PERFCOUNTERS3_ELEMENT_READ);
// sum and count should be identical as we increment TEST_PERCOUNTERS_ELEMENT_READ by 1 nsec eveytime
ASSERT_EQ(dat.first, dat.second);
}
}
TEST(PerfCounters, read_avg) {
std::shared_ptr<PerfCounters> fake_pf = setup_test_perfcounter3(g_ceph_context);
std::thread t1(counters_inc_test, fake_pf);
std::thread t2(counters_readavg_test, fake_pf);
t2.join();
t1.join();
}
static PerfCounters* setup_test_perfcounter4(std::string name, CephContext *cct)
{
PerfCountersBuilder bld(cct, name,
TEST_PERFCOUNTERS2_ELEMENT_FIRST, TEST_PERFCOUNTERS2_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS2_ELEMENT_FOO, "foo");
bld.add_time(TEST_PERFCOUNTERS2_ELEMENT_BAR, "bar");
PerfCounters* counters = bld.create_perf_counters();
cct->get_perfcounters_collection()->add(counters);
return counters;
}
TEST(PerfCounters, TestLabeledCountersOnly) {
constexpr std::string_view empty_dump_format_raw = R"({}
)";
std::string counter_key1 = ceph::perf_counters::key_create("name1", {{"label1", "val1"}});
std::string counter_key2 = ceph::perf_counters::key_create("name2", {{"label2", "val2"}});
std::string counter_key3 = ceph::perf_counters::key_create("name1", {{"label1", "val3"}});
PerfCounters* counters1 = setup_test_perfcounter4(counter_key1, g_ceph_context);
PerfCounters* counters2 = setup_test_perfcounter4(counter_key2, g_ceph_context);
PerfCounters* counters3 = setup_test_perfcounter4(counter_key3, g_ceph_context);
counters1->inc(TEST_PERFCOUNTERS2_ELEMENT_FOO, 3);
counters1->dec(TEST_PERFCOUNTERS2_ELEMENT_FOO, 1);
counters2->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
counters3->inc(TEST_PERFCOUNTERS2_ELEMENT_FOO, 3);
AdminSocketClient client(get_rand_socket_path());
std::string message;
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"name1": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 2,
"bar": 0.000000000
}
},
{
"labels": {
"label1": "val3"
},
"counters": {
"foo": 3,
"bar": 0.000000000
}
}
],
"name2": [
{
"labels": {
"label2": "val2"
},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
]
}
)", message);
// make sure labeled counters are not in normal perf dump
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf dump", "format": "raw" })", &message));
ASSERT_EQ(empty_dump_format_raw, message);
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"name1": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
},
{
"labels": {
"label1": "val3"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"name2": [
{
"labels": {
"label2": "val2"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
]
}
)", message);
// make sure labeled counters are not in normal perf schema
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf schema", "format": "raw" })", &message));
ASSERT_EQ(empty_dump_format_raw, message);
g_ceph_context->get_perfcounters_collection()->clear();
}
TEST(PerfCounters, TestLabelStrings) {
AdminSocketClient client(get_rand_socket_path());
std::string message;
// test empty val in a label pair will get the label pair added but empty key will not
std::string counter_key1 = ceph::perf_counters::key_create("good_ctrs", {{"label3", "val4"}, {"label1", ""}});
PerfCounters* counters1 = setup_test_perfcounter4(counter_key1, g_ceph_context);
std::string counter_key2 = ceph::perf_counters::key_create("bad_ctrs", {{"", "val4"}, {"label1", "val1"}});
PerfCounters* counters2 = setup_test_perfcounter4(counter_key2, g_ceph_context);
counters1->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 2);
counters2->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
// test empty keys in each of the label pairs will get only the labels section added
std::string counter_key3 = ceph::perf_counters::key_create("bad_ctrs2", {{"", "val2"}, {"", "val33"}});
PerfCounters* counters3 = setup_test_perfcounter4(counter_key3, g_ceph_context);
counters3->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 6);
// a key with a somehow odd number of entries after the the key name will omit final unfinished label pair
std::string counter_key4 = "too_many_delimiters";
counter_key4 += '\0';
counter_key4 += "label1";
counter_key4 += '\0';
counter_key4 += "val1";
counter_key4 += '\0';
counter_key4 += "label2";
counter_key4 += '\0';
PerfCounters* counters4 = setup_test_perfcounter4(counter_key4, g_ceph_context);
counters4->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 8);
// test unlabeled perf counters are in the counter dump with labels and counters sections
std::string counter_key5 = "only_key";
PerfCounters* no_label_counters = setup_test_perfcounter4(counter_key5, g_ceph_context);
no_label_counters->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"bad_ctrs": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
],
"bad_ctrs2": [
{
"labels": {},
"counters": {
"foo": 6,
"bar": 0.000000000
}
}
],
"good_ctrs": [
{
"labels": {
"label1": "",
"label3": "val4"
},
"counters": {
"foo": 2,
"bar": 0.000000000
}
}
],
"only_key": [
{
"labels": {},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
],
"too_many_delimiters": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 8,
"bar": 0.000000000
}
}
]
}
)", message);
// test unlabeled perf counters are in the schema dump with labels and counters sections
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"bad_ctrs": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"bad_ctrs2": [
{
"labels": {},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"good_ctrs": [
{
"labels": {
"label1": "",
"label3": "val4"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"only_key": [
{
"labels": {},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"too_many_delimiters": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
]
}
)", message);
// test unlabeled perf counters are in the perf dump without the labels and counters section
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"only_key": {
"foo": 4,
"bar": 0.000000000
}
}
)", message);
// test unlabeled perf counters are in the perf schema without the labels and counters section
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"only_key": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
)", message);
g_ceph_context->get_perfcounters_collection()->clear();
}
| 23,801 | 33.34632 | 502 |
cc
|
null |
ceph-main/src/test/perf_helper.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "include/buffer.h"
#include "common/error_code.h"
using namespace ceph;
namespace PerfHelper {
/// Flush the CPU data cache by reading and writing 100MB of new data.
void flush_cache()
{
int hundredMegs = 100 * 1024 * 1024;
volatile char* block = new char[hundredMegs];
for (int i = 0; i < hundredMegs; i++)
block[i] = 1;
delete[] block;
}
/// Used in functionCall().
uint64_t plus_one(uint64_t x)
{
return x + 1;
}
/// Used in throwIntNL.
void throw_int()
{
throw 0;
}
/// Used in throwExceptionNL.
void throw_end_of_buffer()
{
throw buffer::end_of_buffer();
}
}
| 1,477 | 26.886792 | 77 |
cc
|
null |
ceph-main/src/test/perf_helper.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef CEPH_TEST_PERFHELPER_H
#define CEPH_TEST_PERFHELPER_H
namespace PerfHelper {
void flush_cache();
uint64_t plus_one(uint64_t x);
void throw_end_of_buffer();
void throw_int();
} // PerfHelper
#endif // CEPH_TEST_PERFHELPER_H
| 1,098 | 34.451613 | 77 |
h
|
null |
ceph-main/src/test/perf_local.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2015 Haomai Wang <[email protected]>
* Copyright (c) 2011-2014 Stanford University
* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
// This program contains a collection of low-level performance measurements
// for Ceph, which can be run either individually or altogether. These
// tests measure performance in a single stand-alone process, not in a cluster
// with multiple servers. Invoke the program like this:
//
// Perf test1 test2 ...
//
// test1 and test2 are the names of individual performance measurements to
// run. If no test names are provided then all of the performance tests
// are run.
//
// To add a new test:
// * Write a function that implements the test. Use existing test functions
// as a guideline, and be sure to generate output in the same form as
// other tests.
// * Create a new entry for the test in the #tests table.
#include <vector>
#include <sched.h>
#include "acconfig.h"
#ifdef HAVE_SSE
#include <xmmintrin.h>
#endif
#include "include/buffer.h"
#include "include/encoding.h"
#include "include/ceph_hash.h"
#include "include/spinlock.h"
#include "common/ceph_argparse.h"
#include "common/Cycles.h"
#include "common/Cond.h"
#include "common/ceph_mutex.h"
#include "common/Thread.h"
#include "common/Timer.h"
#include "msg/async/Event.h"
#include "global/global_init.h"
#include "test/perf_helper.h"
#include <atomic>
using namespace std;
using namespace ceph;
/**
* Ask the operating system to pin the current thread to a given CPU.
*
* \param cpu
* Indicates the desired CPU and hyperthread; low order 2 bits
* specify CPU, next bit specifies hyperthread.
*/
void bind_thread_to_cpu(int cpu)
{
#ifdef HAVE_SCHED
cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(cpu, &set);
sched_setaffinity(0, sizeof(set), &set);
#endif
}
/*
* This function just discards its argument. It's used to make it
* appear that data is used, so that the compiler won't optimize
* away the code we're trying to measure.
*
* \param value
* Pointer to arbitrary value; it's discarded.
*/
void discard(void* value) {
int x = *reinterpret_cast<int*>(value);
if (x == 0x43924776) {
printf("Value was 0x%x\n", x);
}
}
//----------------------------------------------------------------------
// Test functions start here
//----------------------------------------------------------------------
// Measure the cost of atomic compare-and-swap
double atomic_int_cmp()
{
int count = 1000000;
std::atomic<unsigned> value = { 11 };
unsigned int test = 11;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value.compare_exchange_strong(test, test+2);
test += 2;
}
uint64_t stop = Cycles::rdtsc();
// printf("Final value: %d\n", value.load());
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of incrementing an atomic
double atomic_int_inc()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value++;
}
uint64_t stop = Cycles::rdtsc();
// printf("Final value: %d\n", value.load());
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of reading an atomic
double atomic_int_read()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
[[maybe_unused]] int total = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += value;
}
uint64_t stop = Cycles::rdtsc();
// printf("Total: %d\n", total);
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of storing a new value in an atomic
double atomic_int_set()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value = 88;
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of acquiring and releasing a mutex in the
// fast case where the mutex is free.
double mutex_nonblock()
{
int count = 1000000;
ceph::mutex m = ceph::make_mutex("mutex_nonblock::m");
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
m.lock();
m.unlock();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating and deallocating a buffer, plus
// appending (logically) one ptr.
double buffer_basic()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
bufferptr ptr("abcdefg", 7);
for (int i = 0; i < count; i++) {
bufferlist b;
b.append(ptr, 0, 5);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
struct DummyBlock {
int a = 1, b = 2, c = 3, d = 4;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
encode(a, bl);
encode(b, bl);
encode(c, bl);
encode(d, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(a, bl);
decode(b, bl);
decode(c, bl);
decode(d, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(DummyBlock)
// Measure the cost of encoding and decoding a buffer, plus
// allocating space for one chunk.
double buffer_encode_decode()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
bufferlist b;
DummyBlock dummy_block;
encode(dummy_block, b);
auto iter = b.cbegin();
decode(dummy_block, iter);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating and deallocating a buffer, plus
// copying in a small block.
double buffer_basic_copy()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
bufferlist b;
b.append("abcdefg", 6);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of making a copy of parts of two ptrs.
double buffer_copy()
{
int count = 1000000;
bufferlist b;
b.append("abcde", 5);
b.append("01234", 5);
char copy[10];
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
b.cbegin(2).copy(6, copy);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating new space by extending the
// bufferlist
double buffer_encode()
{
int count = 100000;
uint64_t total = 0;
for (int i = 0; i < count; i++) {
bufferlist b;
DummyBlock dummy_block;
encode(dummy_block, b);
uint64_t start = Cycles::rdtsc();
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
total += Cycles::rdtsc() - start;
}
return Cycles::to_seconds(total)/(count*10);
}
// Measure the cost of creating an iterator and iterating over 10
// chunks in a buffer.
double buffer_iterator()
{
bufferlist b;
const char s[] = "abcdefghijklmnopqrstuvwxyz";
bufferptr ptr(s, sizeof(s));
for (int i = 0; i < 5; i++) {
b.append(ptr, i, 5);
}
int count = 100000;
int sum = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
auto it = b.cbegin();
while (!it.end()) {
sum += (static_cast<const char*>(it.get_current_ptr().c_str()))[it.get_remaining()-1];
++it;
}
}
uint64_t stop = Cycles::rdtsc();
discard(&sum);
return Cycles::to_seconds(stop - start)/count;
}
// Implements the CondPingPong test.
class CondPingPong {
ceph::mutex mutex = ceph::make_mutex("CondPingPong::mutex");
ceph::condition_variable cond;
int prod = 0;
int cons = 0;
const int count = 10000;
class Consumer : public Thread {
CondPingPong *p;
public:
explicit Consumer(CondPingPong *p): p(p) {}
void* entry() override {
p->consume();
return 0;
}
} consumer;
public:
CondPingPong(): consumer(this) {}
double run() {
consumer.create("consumer");
uint64_t start = Cycles::rdtsc();
produce();
uint64_t stop = Cycles::rdtsc();
consumer.join();
return Cycles::to_seconds(stop - start)/count;
}
void produce() {
std::unique_lock l{mutex};
while (cons < count) {
cond.wait(l, [this] { return cons >= prod; });
++prod;
cond.notify_all();
}
}
void consume() {
std::unique_lock l{mutex};
while (cons < count) {
cond.wait(l, [this] { return cons != prod; });
++cons;
cond.notify_all();
}
}
};
// Measure the cost of coordinating between threads using a condition variable.
double cond_ping_pong()
{
return CondPingPong().run();
}
// Measure the cost of a 32-bit divide. Divides don't take a constant
// number of cycles. Values were chosen here semi-randomly to depict a
// fairly expensive scenario. Someone with fancy ALU knowledge could
// probably pick worse values.
double div32()
{
#if defined(__i386__) || defined(__x86_64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
// NB: Expect an x86 processor exception is there's overflow.
uint32_t numeratorHi = 0xa5a5a5a5U;
uint32_t numeratorLo = 0x55aa55aaU;
uint32_t divisor = 0xaa55aa55U;
uint32_t quotient;
uint32_t remainder;
for (int i = 0; i < count; i++) {
__asm__ __volatile__("div %4" :
"=a"(quotient), "=d"(remainder) :
"a"(numeratorLo), "d"(numeratorHi), "r"(divisor) :
"cc");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
uint64_t numerator = 0xa5a5a5a555aa55aaUL;
uint32_t divisor = 0xaa55aa55U;
uint32_t result;
for (int i = 0; i < count; i++) {
asm volatile("udiv %0, %1, %2" : "=r"(result) :
"r"(numerator), "r"(divisor));
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of a 64-bit divide. Divides don't take a constant
// number of cycles. Values were chosen here semi-randomly to depict a
// fairly expensive scenario. Someone with fancy ALU knowledge could
// probably pick worse values.
double div64()
{
#if defined(__x86_64__) || defined(__amd64__)
int count = 1000000;
// NB: Expect an x86 processor exception is there's overflow.
uint64_t start = Cycles::rdtsc();
uint64_t numeratorHi = 0x5a5a5a5a5a5UL;
uint64_t numeratorLo = 0x55aa55aa55aa55aaUL;
uint64_t divisor = 0xaa55aa55aa55aa55UL;
uint64_t quotient;
uint64_t remainder;
for (int i = 0; i < count; i++) {
__asm__ __volatile__("divq %4" :
"=a"(quotient), "=d"(remainder) :
"a"(numeratorLo), "d"(numeratorHi), "r"(divisor) :
"cc");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of calling a non-inlined function.
double function_call()
{
int count = 1000000;
uint64_t x = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
x = PerfHelper::plus_one(x);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the minimum cost of EventCenter::process_events, when there are no
// Pollers and no Timers.
double eventcenter_poll()
{
int count = 1000000;
EventCenter center(g_ceph_context);
center.init(1000, 0, "posix");
center.set_owner();
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
center.process_events(0);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
class CenterWorker : public Thread {
CephContext *cct;
bool done;
public:
EventCenter center;
explicit CenterWorker(CephContext *c): cct(c), done(false), center(c) {
center.init(100, 0, "posix");
}
void stop() {
done = true;
center.wakeup();
}
void* entry() override {
center.set_owner();
bind_thread_to_cpu(2);
while (!done)
center.process_events(1000);
return 0;
}
};
class CountEvent: public EventCallback {
std::atomic<int64_t> *count;
public:
explicit CountEvent(std::atomic<int64_t> *atomic): count(atomic) {}
void do_request(uint64_t id) override {
(*count)--;
}
};
double eventcenter_dispatch()
{
int count = 100000;
CenterWorker worker(g_ceph_context);
std::atomic<int64_t> flag = { 1 };
worker.create("evt_center_disp");
EventCallbackRef count_event(new CountEvent(&flag));
worker.center.dispatch_event_external(count_event);
// Start a new thread and wait for it to ready.
while (flag)
usleep(100);
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
flag = 1;
worker.center.dispatch_event_external(count_event);
while (flag)
;
}
uint64_t stop = Cycles::rdtsc();
worker.stop();
worker.join();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of copying a given number of bytes with memcpy.
double memcpy_shared(size_t size)
{
int count = 1000000;
char src[size], dst[size];
memset(src, 0, sizeof(src));
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
memcpy(dst, src, size);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
double memcpy100()
{
return memcpy_shared(100);
}
double memcpy1000()
{
return memcpy_shared(1000);
}
double memcpy10000()
{
return memcpy_shared(10000);
}
// Benchmark rjenkins hashing performance on cached data.
template <int key_length>
double ceph_str_hash_rjenkins()
{
int count = 100000;
char buf[key_length];
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++)
ceph_str_hash(CEPH_STR_HASH_RJENKINS, buf, sizeof(buf));
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of reading the fine-grain cycle counter.
double rdtsc_test()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
[[maybe_unused]] uint64_t total = 0;
for (int i = 0; i < count; i++) {
total += Cycles::rdtsc();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of the Cycles::to_seconds method.
double perf_cycles_to_seconds()
{
int count = 1000000;
[[maybe_unused]] double total = 0;
uint64_t cycles = 994261;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += Cycles::to_seconds(cycles);
}
uint64_t stop = Cycles::rdtsc();
// printf("Result: %.4f\n", total/count);
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of the Cylcles::toNanoseconds method.
double perf_cycles_to_nanoseconds()
{
int count = 1000000;
[[maybe_unused]] uint64_t total = 0;
uint64_t cycles = 994261;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += Cycles::to_nanoseconds(cycles);
}
uint64_t stop = Cycles::rdtsc();
// printf("Result: %lu\n", total/count);
return Cycles::to_seconds(stop - start)/count;
}
#ifdef HAVE_SSE
/**
* Prefetch the cache lines containing [object, object + numBytes) into the
* processor's caches.
* The best docs for this are in the Intel instruction set reference under
* PREFETCH.
* \param object
* The start of the region of memory to prefetch.
* \param num_bytes
* The size of the region of memory to prefetch.
*/
static inline void prefetch(const void *object, uint64_t num_bytes)
{
uint64_t offset = reinterpret_cast<uint64_t>(object) & 0x3fUL;
const char* p = reinterpret_cast<const char*>(object) - offset;
for (uint64_t i = 0; i < offset + num_bytes; i += 64)
_mm_prefetch(p + i, _MM_HINT_T0);
}
#elif defined(__aarch64__)
static inline void prefetch(const void *object, uint64_t num_bytes)
{
uint64_t offset = reinterpret_cast<uint64_t>(object) & 0x3fUL;
const char* ptr = reinterpret_cast<const char*>(object) - offset;
for (uint64_t i = 0; i < offset + num_bytes; i += 64, ptr += 64)
asm volatile("prfm pldl1keep, %a0\n" : : "p" (ptr));
}
#endif
// Measure the cost of the prefetch instruction.
double perf_prefetch()
{
#if defined(HAVE_SSE) || defined(__aarch64__)
uint64_t total_ticks = 0;
int count = 10;
char buf[16 * 64];
for (int i = 0; i < count; i++) {
PerfHelper::flush_cache();
uint64_t start = Cycles::rdtsc();
prefetch(&buf[576], 64);
prefetch(&buf[0], 64);
prefetch(&buf[512], 64);
prefetch(&buf[960], 64);
prefetch(&buf[640], 64);
prefetch(&buf[896], 64);
prefetch(&buf[256], 64);
prefetch(&buf[704], 64);
prefetch(&buf[320], 64);
prefetch(&buf[384], 64);
prefetch(&buf[128], 64);
prefetch(&buf[448], 64);
prefetch(&buf[768], 64);
prefetch(&buf[832], 64);
prefetch(&buf[64], 64);
prefetch(&buf[192], 64);
uint64_t stop = Cycles::rdtsc();
total_ticks += stop - start;
}
return Cycles::to_seconds(total_ticks) / count / 16;
#else
return -1;
#endif
}
#if defined(__x86_64__)
/**
* This function is used to seralize machine instructions so that no
* instructions that appear after it in the current thread can run before any
* instructions that appear before it.
*
* It is useful for putting around rdpmc instructions (to pinpoint cache
* misses) as well as before rdtsc instructions, to prevent time pollution from
* instructions supposed to be executing before the timer starts.
*/
static inline void serialize() {
uint32_t eax, ebx, ecx, edx;
__asm volatile("cpuid"
: "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
: "a" (1U));
}
#endif
// Measure the cost of cpuid
double perf_serialize() {
#if defined(__x86_64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
serialize();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of an lfence instruction.
double lfence()
{
#ifdef HAVE_SSE2
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
__asm__ __volatile__("lfence" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
asm volatile("dmb ishld" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of an sfence instruction.
double sfence()
{
#ifdef HAVE_SSE
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
__asm__ __volatile__("sfence" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
asm volatile("dmb ishst" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of acquiring and releasing a SpinLock (assuming the
// lock is initially free).
double test_spinlock()
{
int count = 1000000;
ceph::spinlock lock;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
lock.lock();
lock.unlock();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Helper for spawn_thread. This is the main function that the thread executes
// (intentionally empty).
class ThreadHelper : public Thread {
void *entry() override { return 0; }
};
// Measure the cost of start and joining with a thread.
double spawn_thread()
{
int count = 10000;
ThreadHelper thread;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
thread.create("thread_helper");
thread.join();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
class FakeContext : public Context {
public:
void finish(int r) override {}
};
// Measure the cost of starting and stopping a Dispatch::Timer.
double perf_timer()
{
int count = 1000000;
ceph::mutex lock = ceph::make_mutex("perf_timer::lock");
SafeTimer timer(g_ceph_context, lock);
FakeContext **c = new FakeContext*[count];
for (int i = 0; i < count; i++) {
c[i] = new FakeContext();
}
uint64_t start = Cycles::rdtsc();
std::lock_guard l{lock};
for (int i = 0; i < count; i++) {
if (timer.add_event_after(12345, c[i])) {
timer.cancel_event(c[i]);
}
}
uint64_t stop = Cycles::rdtsc();
delete[] c;
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an int. This uses an integer as
// the value thrown, which is presumably as fast as possible.
double throw_int()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
throw 0;
} catch (int) { // NOLINT
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an int from a function call.
double throw_int_call()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
PerfHelper::throw_int();
} catch (int) { // NOLINT
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an Exception. This uses an actual
// exception as the value thrown, which may be slower than throwInt.
double throw_exception()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
throw buffer::end_of_buffer();
} catch (const buffer::end_of_buffer&) {
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an Exception from a function call.
double throw_exception_call()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
PerfHelper::throw_end_of_buffer();
} catch (const buffer::end_of_buffer&) {
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of pushing a new element on a std::vector, copying
// from the end to an internal element, and popping the end element.
double vector_push_pop()
{
int count = 100000;
std::vector<int> vector;
vector.push_back(1);
vector.push_back(2);
vector.push_back(3);
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
vector.push_back(i);
vector.push_back(i+1);
vector.push_back(i+2);
vector[2] = vector.back();
vector.pop_back();
vector[0] = vector.back();
vector.pop_back();
vector[1] = vector.back();
vector.pop_back();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/(count*3);
}
// Measure the cost of ceph_clock_now
double perf_ceph_clock_now()
{
int count = 100000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
ceph_clock_now();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// The following struct and table define each performance test in terms of
// a string name and a function that implements the test.
struct TestInfo {
const char* name; // Name of the performance test; this is
// what gets typed on the command line to
// run the test.
double (*func)(); // Function that implements the test;
// returns the time (in seconds) for each
// iteration of that test.
const char *description; // Short description of this test (not more
// than about 40 characters, so the entire
// test output fits on a single line).
};
TestInfo tests[] = {
{"atomic_int_cmp", atomic_int_cmp,
"atomic_t::compare_and_swap"},
{"atomic_int_inc", atomic_int_inc,
"atomic_t::inc"},
{"atomic_int_read", atomic_int_read,
"atomic_t::read"},
{"atomic_int_set", atomic_int_set,
"atomic_t::set"},
{"mutex_nonblock", mutex_nonblock,
"Mutex lock/unlock (no blocking)"},
{"buffer_basic", buffer_basic,
"buffer create, add one ptr, delete"},
{"buffer_encode_decode", buffer_encode_decode,
"buffer create, encode/decode object, delete"},
{"buffer_basic_copy", buffer_basic_copy,
"buffer create, copy small block, delete"},
{"buffer_copy", buffer_copy,
"copy out 2 small ptrs from buffer"},
{"buffer_encode10", buffer_encode,
"buffer encoding 10 structures onto existing ptr"},
{"buffer_iterator", buffer_iterator,
"iterate over buffer with 5 ptrs"},
{"cond_ping_pong", cond_ping_pong,
"condition variable round-trip"},
{"div32", div32,
"32-bit integer division instruction"},
{"div64", div64,
"64-bit integer division instruction"},
{"function_call", function_call,
"Call a function that has not been inlined"},
{"eventcenter_poll", eventcenter_poll,
"EventCenter::process_events (no timers or events)"},
{"eventcenter_dispatch", eventcenter_dispatch,
"EventCenter::dispatch_event_external latency"},
{"memcpy100", memcpy100,
"Copy 100 bytes with memcpy"},
{"memcpy1000", memcpy1000,
"Copy 1000 bytes with memcpy"},
{"memcpy10000", memcpy10000,
"Copy 10000 bytes with memcpy"},
{"ceph_str_hash_rjenkins", ceph_str_hash_rjenkins<16>,
"rjenkins hash on 16 byte of data"},
{"ceph_str_hash_rjenkins", ceph_str_hash_rjenkins<256>,
"rjenkins hash on 256 bytes of data"},
{"rdtsc", rdtsc_test,
"Read the fine-grain cycle counter"},
{"cycles_to_seconds", perf_cycles_to_seconds,
"Convert a rdtsc result to (double) seconds"},
{"cycles_to_seconds", perf_cycles_to_nanoseconds,
"Convert a rdtsc result to (uint64_t) nanoseconds"},
{"prefetch", perf_prefetch,
"Prefetch instruction"},
{"serialize", perf_serialize,
"serialize instruction"},
{"lfence", lfence,
"Lfence instruction"},
{"sfence", sfence,
"Sfence instruction"},
{"spin_lock", test_spinlock,
"Acquire/release SpinLock"},
{"spawn_thread", spawn_thread,
"Start and stop a thread"},
{"perf_timer", perf_timer,
"Insert and cancel a SafeTimer"},
{"throw_int", throw_int,
"Throw an int"},
{"throw_int_call", throw_int_call,
"Throw an int in a function call"},
{"throw_exception", throw_exception,
"Throw an Exception"},
{"throw_exception_call", throw_exception_call,
"Throw an Exception in a function call"},
{"vector_push_pop", vector_push_pop,
"Push and pop a std::vector"},
{"ceph_clock_now", perf_ceph_clock_now,
"ceph_clock_now function"},
};
/**
* Runs a particular test and prints a one-line result message.
*
* \param info
* Describes the test to run.
*/
void run_test(TestInfo& info)
{
double secs = info.func();
int width = printf("%-24s ", info.name);
if (secs == -1) {
width += printf(" architecture nonsupport ");
} else if (secs < 1.0e-06) {
width += printf("%8.2fns", 1e09*secs);
} else if (secs < 1.0e-03) {
width += printf("%8.2fus", 1e06*secs);
} else if (secs < 1.0) {
width += printf("%8.2fms", 1e03*secs);
} else {
width += printf("%8.2fs", secs);
}
printf("%*s %s\n", 32-width, "", info.description);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
Cycles::init();
bind_thread_to_cpu(3);
if (argc == 1) {
// No test names specified; run all tests.
for (size_t i = 0; i < sizeof(tests)/sizeof(TestInfo); ++i) {
run_test(tests[i]);
}
} else {
// Run only the tests that were specified on the command line.
for (int i = 1; i < argc; i++) {
bool found_test = false;
for (size_t j = 0; j < sizeof(tests)/sizeof(TestInfo); ++j) {
if (strcmp(argv[i], tests[j].name) == 0) {
found_test = true;
run_test(tests[j]);
break;
}
}
if (!found_test) {
int width = printf("%-24s ??", argv[i]);
printf("%*s No such test\n", 32-width, "");
}
}
}
}
| 29,610 | 26.725655 | 92 |
cc
|
null |
ceph-main/src/test/rbd-ggate.sh
|
#!/usr/bin/env bash
#
# Copyright (C) 2014, 2015 Red Hat <[email protected]>
# Copyright (C) 2013 Cloudwatt <[email protected]>
#
# Author: Loic Dachary <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Library Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library Public License for more details.
#
set -ex
source $(dirname $0)/detect-build-env-vars.sh
test `uname` = FreeBSD
CEPH_CLI_TEST_DUP_COMMAND=1 \
MON=1 OSD=3 MDS=0 MGR=1 CEPH_PORT=7206 $CEPH_ROOT/src/test/vstart_wrapper.sh \
$CEPH_ROOT/qa/workunits/rbd/rbd-ggate.sh \
| 901 | 33.692308 | 78 |
sh
|
null |
ceph-main/src/test/run-rbd-unit-tests.sh
|
#!/usr/bin/env bash
set -ex
# this should be run from the src directory in the ceph.git
source $(dirname $0)/detect-build-env-vars.sh
PATH="$CEPH_BIN:$PATH"
if [ $# = 0 ]; then
# mimic the old behaviour
TESTS='0 1 61 109 127'
unset RBD_FEATURES; unittest_librbd
elif [ $# = 1 -a "${1}" = N ] ; then
# new style no feature request
unset RBD_FEATURES; unittest_librbd
else
TESTS="$*"
fi
for i in ${TESTS}
do
RBD_FEATURES=$i unittest_librbd
done
echo OK
| 473 | 17.230769 | 59 |
sh
|
null |
ceph-main/src/test/run-rbd-valgrind-unit-tests.sh
|
#!/usr/bin/env bash
set -ex
# this should be run from the src directory in the ceph.git (when built with
# automake) or cmake build directory
source $(dirname $0)/detect-build-env-vars.sh
RBD_FEATURES=13 valgrind --tool=memcheck --leak-check=full --error-exitcode=1 \
--suppressions=${CEPH_ROOT}/qa/valgrind.supp unittest_librbd
echo OK
| 346 | 25.692308 | 79 |
sh
|
null |
ceph-main/src/test/run_cmd.cc
|
#include "common/config.h"
#include "common/run_cmd.h"
#include "gtest/gtest.h"
#include <stdlib.h>
#include <unistd.h>
TEST(RunCommand, StringSimple)
{
char temp_file_name[] = "run_cmd_temp_file_XXXXXX";
int fd = ::mkstemp(temp_file_name);
ASSERT_GE(fd, 0);
::close(fd);
std::string ret = run_cmd("touch", temp_file_name, (char*)NULL);
ASSERT_EQ(ret, "");
ASSERT_EQ(access(temp_file_name, R_OK), 0);
ret = run_cmd("rm", "-f", temp_file_name, (char*)NULL);
ASSERT_EQ(ret, "");
ASSERT_NE(access(temp_file_name, R_OK), 0);
}
| 551 | 19.444444 | 66 |
cc
|
null |
ceph-main/src/test/signals.cc
|
#include "common/config.h"
#include "common/signal.h"
#include "global/signal_handler.h"
#include "common/debug.h"
#include "include/coredumpctl.h"
#include "gtest/gtest.h"
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
static volatile sig_atomic_t got_sigusr1 = 0;
static void handle_sigusr1(int signo)
{
got_sigusr1 = 1;
}
TEST(SignalApi, SimpleInstall)
{
install_sighandler(SIGPIPE, handle_sigusr1, 0);
}
TEST(SignalApi, SimpleInstallAndTest)
{
install_sighandler(SIGPIPE, handle_sigusr1, 0);
// SIGPIPE starts out blocked
int ret = kill(getpid(), SIGPIPE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(got_sigusr1, 0);
// handle SIGPIPE
sigset_t mask;
sigemptyset(&mask);
ret = sigsuspend(&mask);
if (ret == -1)
ret = errno;
// we should have gotten it
ASSERT_EQ(ret, EINTR);
ASSERT_EQ(got_sigusr1, 1);
}
TEST(SignalEffects, ErrnoTest1)
{
}
bool usr1 = false;
bool usr2 = false;
void reset()
{
usr1 = false;
usr2 = false;
}
void testhandler(int signal)
{
switch (signal) {
case SIGUSR1:
usr1 = true;
break;
case SIGUSR2:
usr2 = true;
break;
default:
ceph_abort_msg("unexpected signal");
}
}
TEST(SignalHandler, Single)
{
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
ASSERT_TRUE(usr1 == false);
int ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
shutdown_async_signal_handler();
}
TEST(SignalHandler, Multiple)
{
int ret;
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
register_async_signal_handler(SIGUSR2, testhandler);
ASSERT_TRUE(usr1 == false);
ASSERT_TRUE(usr2 == false);
ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
ret = kill(getpid(), SIGUSR2);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
ASSERT_TRUE(usr2 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
unregister_async_signal_handler(SIGUSR2, testhandler);
shutdown_async_signal_handler();
}
TEST(SignalHandler, LogInternal)
{
g_ceph_context->_log->inject_segv();
{
PrCtl unset_dumpable;
ASSERT_DEATH(derr << "foo" << dendl, ".*");
}
g_ceph_context->_log->reset_segv();
}
/*
TEST(SignalHandler, MultipleBigFd)
{
int ret;
for (int i = 0; i < 1500; i++)
::open(".", O_RDONLY);
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
register_async_signal_handler(SIGUSR2, testhandler);
ASSERT_TRUE(usr1 == false);
ASSERT_TRUE(usr2 == false);
ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
ret = kill(getpid(), SIGUSR2);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
ASSERT_TRUE(usr2 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
unregister_async_signal_handler(SIGUSR2, testhandler);
shutdown_async_signal_handler();
}
*/
| 3,064 | 18.27673 | 56 |
cc
|
null |
ceph-main/src/test/simple_spin.cc
|
#include <future>
#include "gtest/gtest.h"
#include "include/spinlock.h"
using ceph::spin_lock;
using ceph::spin_unlock;
static std::atomic_flag lock = ATOMIC_FLAG_INIT;
static int64_t counter = 0;
TEST(SimpleSpin, Test0)
{
std::atomic_flag lock0 = ATOMIC_FLAG_INIT;
spin_lock(&lock0);
spin_unlock(&lock0);
}
static void* mythread(void *v)
{
for (int j = 0; j < 1000000; ++j) {
spin_lock(&lock);
counter++;
spin_unlock(&lock);
}
return NULL;
}
TEST(SimpleSpin, Test1)
{
counter = 0;
const auto n = 2000000U;
int ret;
pthread_t thread1;
pthread_t thread2;
ret = pthread_create(&thread1, NULL, mythread, NULL);
ASSERT_EQ(0, ret);
ret = pthread_create(&thread2, NULL, mythread, NULL);
ASSERT_EQ(0, ret);
ret = pthread_join(thread1, NULL);
ASSERT_EQ(0, ret);
ret = pthread_join(thread2, NULL);
ASSERT_EQ(0, ret);
ASSERT_EQ(n, counter);
// Should also work with pass-by-reference:
// (Note that we don't care about cross-threading here as-such.)
counter = 0;
auto f = async(std::launch::async, []() {
for(int i = 0; n != i; ++i) {
spin_lock(lock);
counter++;
spin_unlock(lock);
}
});
f.wait();
ASSERT_EQ(n, counter);
}
template <typename LockT>
int64_t check_lock_unlock(const int64_t n, int64_t& cntr, LockT& lock)
{
auto do_lock_unlock = [&]() -> int64_t {
int64_t i = 0;
for(; n != i; ++i) {
spin_lock(lock);
cntr++;
spin_unlock(lock);
}
return i;
};
auto fone = async(std::launch::async, do_lock_unlock);
auto ftwo = async(std::launch::async, do_lock_unlock);
auto fthree = async(std::launch::async, do_lock_unlock);
auto one = fone.get();
auto two = ftwo.get();
auto three = fthree.get();
// Google test doesn't like us using its macros out of individual tests, so:
if(n != one || n != two || n != three)
return 0;
return one + two + three;
}
TEST(SimpleSpin, Test2)
{
const auto n = 2000000U;
// ceph::spinlock:
{
counter = 0;
ceph::spinlock l;
ASSERT_EQ(0, counter);
auto result = check_lock_unlock(n, counter, l);
ASSERT_NE(0, counter);
ASSERT_EQ(counter, result);
}
}
// ceph::spinlock should work with std::lock_guard<>:
TEST(SimpleSpin, spinlock_guard)
{
const auto n = 2000000U;
ceph::spinlock sl;
counter = 0;
auto f = async(std::launch::async, [&sl]() {
for(int i = 0; n != i; ++i) {
std::lock_guard<ceph::spinlock> g(sl);
counter++;
}
});
auto g = async(std::launch::async, [&sl]() {
for(int i = 0; n != i; ++i) {
std::lock_guard<ceph::spinlock> g(sl);
counter++;
}
});
f.wait();
g.wait();
ASSERT_EQ(2*n, counter);
}
| 2,783 | 19.470588 | 77 |
cc
|
null |
ceph-main/src/test/smoke.sh
|
#!/usr/bin/env bash
source $CEPH_ROOT/qa/standalone/ceph-helpers.sh
mon_port=$(get_unused_port)
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:$mon_port"
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
set -e
local funcs=${@:-$(set | sed -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
setup $dir || return 1
$func $dir || return 1
teardown $dir || return 1
done
}
function TEST_minimal() {
local dir=$1
run_mon $dir a
run_mgr $dir x
run_osd $dir 0
run_osd $dir 1
run_osd $dir 2
create_rbd_pool
wait_for_clean
}
function TEST_multimon() {
local dir=$1
MONA="127.0.0.1:$((mon_port++))"
MONB="127.0.0.1:$((mon_port++))"
MONC="127.0.0.1:$((mon_port++))"
run_mon $dir a --public-addr $MONA
run_mon $dir b --public-addr $MONB
run_mon $dir c --public_addr $MONC
run_mgr $dir x
run_mgr $dir y
run_osd $dir 0
run_osd $dir 1
run_osd $dir 2
ceph osd pool create foo 32
ceph osd out 0
wait_for_clean
timeout 20 rados -p foo bench 4 write -b 4096 --no-cleanup || return 1
wait_for_clean
ceph osd in 0
flush_pg_stats
wait_for_clean
}
main smoke "$@"
| 1,310 | 19.169231 | 74 |
sh
|
null |
ceph-main/src/test/strtol.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 Dreamhost
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <cmath>
#include <string>
#include <map>
#include "common/strtol.h"
#include "gtest/gtest.h"
static void test_strict_strtoll(const char *str, long long expected, int base)
{
std::string err;
long long val = strict_strtoll(str, base, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
ASSERT_EQ(val, expected);
}
}
static void test_strict_strtol(const char *str, long expected)
{
std::string err;
long val = strict_strtol(str, 10, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
ASSERT_EQ(val, expected);
}
}
static void test_strict_strtod(const char *str, double expected)
{
std::string err;
double val = strict_strtod(str, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
// when comparing floats, use a margin of error
if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
ASSERT_EQ(val, expected);
}
}
}
static void test_strict_strtof(const char *str, float expected)
{
std::string err;
float val = strict_strtof(str, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
// when comparing floats, use a margin of error
if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
ASSERT_EQ(val, expected);
}
}
}
TEST(StrToL, Simple1) {
test_strict_strtoll("123", 123, 10);
test_strict_strtoll("0", 0, 10);
test_strict_strtoll("-123", -123, 10);
test_strict_strtoll("8796093022208", 8796093022208LL, 10);
test_strict_strtoll("-8796093022208", -8796093022208LL, 10);
test_strict_strtoll("123", 123, 0);
test_strict_strtoll("0x7b", 123, 0);
test_strict_strtoll("4d2", 1234, 16);
test_strict_strtol("208", 208);
test_strict_strtol("-4", -4);
test_strict_strtol("0", 0);
test_strict_strtol("2147483646", 2147483646);
test_strict_strtof("0.05", 0.05);
test_strict_strtof("0", 0.0);
test_strict_strtof("-0", 0.0);
test_strict_strtof("10000000.5", 10000000.5);
test_strict_strtod("-0.2", -0.2);
test_strict_strtod("0.1", 0.1);
test_strict_strtod("0", 0.0);
}
static void test_strict_strtoll_err(const char *str)
{
std::string err;
strict_strtoll(str, 10, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtol_err(const char *str)
{
std::string err;
strict_strtol(str, 10, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtod_err(const char *str)
{
std::string err;
strict_strtod(str, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtof_err(const char *str)
{
std::string err;
strict_strtof(str, &err);
ASSERT_NE(err, "");
}
TEST(StrToL, Error1) {
test_strict_strtoll_err("604462909807314587353088"); // overflow
test_strict_strtoll_err("aw shucks"); // invalid
test_strict_strtoll_err("343245 aw shucks"); // invalid chars at end
test_strict_strtoll_err("-"); // invalid
test_strict_strtol_err("35 aw shucks"); // invalid chars at end
test_strict_strtol_err("--0");
test_strict_strtol_err("-");
test_strict_strtod_err("345345.0-");
test_strict_strtod_err("34.0 garbo");
test_strict_strtof_err("0.05.0");
}
static void test_strict_iecstrtoll(const char *str)
{
std::string err;
strict_iecstrtoll(str, &err);
ASSERT_EQ(err, "");
}
static void test_strict_iecstrtoll_units(const std::string& foo,
std::string u, const int m)
{
std::string s(foo);
s.append(u);
const char *str = s.c_str();
std::string err;
uint64_t r = strict_iecstrtoll(str, &err);
ASSERT_EQ(err, "");
str = foo.c_str();
std::string err2;
long long tmp = strict_strtoll(str, 10, &err2);
ASSERT_EQ(err2, "");
tmp = (tmp << m);
ASSERT_EQ(tmp, (long long)r);
}
TEST(IECStrToLL, WithUnits) {
std::map<std::string,int> units;
units["B"] = 0;
units["K"] = 10;
units["M"] = 20;
units["G"] = 30;
units["T"] = 40;
units["P"] = 50;
units["E"] = 60;
units["Ki"] = 10;
units["Mi"] = 20;
units["Gi"] = 30;
units["Ti"] = 40;
units["Pi"] = 50;
units["Ei"] = 60;
for (std::map<std::string,int>::iterator p = units.begin();
p != units.end(); ++p) {
// the upper bound of uint64_t is 2^64 = 4E
test_strict_iecstrtoll_units("4", p->first, p->second);
test_strict_iecstrtoll_units("1", p->first, p->second);
test_strict_iecstrtoll_units("0", p->first, p->second);
}
}
TEST(IECStrToLL, WithoutUnits) {
test_strict_iecstrtoll("1024");
test_strict_iecstrtoll("1152921504606846976");
test_strict_iecstrtoll("0");
}
static void test_strict_iecstrtoll_err(const char *str)
{
std::string err;
strict_iecstrtoll(str, &err);
ASSERT_NE(err, "");
}
TEST(IECStrToLL, Error) {
test_strict_iecstrtoll_err("1024F");
test_strict_iecstrtoll_err("QDDSA");
test_strict_iecstrtoll_err("1b");
test_strict_iecstrtoll_err("100k");
test_strict_iecstrtoll_err("1000m");
test_strict_iecstrtoll_err("1g");
test_strict_iecstrtoll_err("20t");
test_strict_iecstrtoll_err("100p");
test_strict_iecstrtoll_err("1000e");
test_strict_iecstrtoll_err("B");
test_strict_iecstrtoll_err("M");
test_strict_iecstrtoll_err("BM");
test_strict_iecstrtoll_err("B0wef");
test_strict_iecstrtoll_err("0m");
test_strict_iecstrtoll_err("-1"); // it returns uint64_t
test_strict_iecstrtoll_err("-1K");
test_strict_iecstrtoll_err("1Bi");
test_strict_iecstrtoll_err("Bi");
test_strict_iecstrtoll_err("bi");
test_strict_iecstrtoll_err("gi");
test_strict_iecstrtoll_err("100ki");
test_strict_iecstrtoll_err("1000mi");
test_strict_iecstrtoll_err("1gi");
test_strict_iecstrtoll_err("20ti");
test_strict_iecstrtoll_err("100pi");
test_strict_iecstrtoll_err("1000ei");
// the upper bound of uint64_t is 2^64 = 4E, so 1024E overflows
test_strict_iecstrtoll_err("1024E"); // overflows after adding the suffix
}
// since strict_iecstrtoll is an alias of strict_iec_cast<uint64_t>(), quite a few
// of cases are covered by existing test cases of strict_iecstrtoll already.
TEST(StrictIECCast, Error) {
{
std::string err;
// the SI prefix is way too large for `int`.
(void)strict_iec_cast<int>("2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int>("-2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int>("1T", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("-2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("1T", &err);
ASSERT_EQ(err, "");
}
}
static void test_strict_sistrtoll(const char *str)
{
std::string err;
strict_si_cast<uint64_t>(str, &err);
ASSERT_EQ(err, "");
}
static void test_strict_sistrtoll_units(const std::string& foo,
std::string u, const long long m)
{
std::string s(foo);
s.append(u);
const char *str = s.c_str();
std::string err;
uint64_t r = strict_si_cast<uint64_t>(str, &err);
ASSERT_EQ(err, "");
str = foo.c_str();
std::string err2;
long long tmp = strict_strtoll(str, 10, &err2);
ASSERT_EQ(err2, "");
tmp = (tmp * m);
ASSERT_EQ(tmp, (long long)r);
}
TEST(SIStrToLL, WithUnits) {
std::map<std::string,long long> units;
units["K"] = pow(10, 3);
units["M"] = pow(10, 6);
units["G"] = pow(10, 9);
units["T"] = pow(10, 12);
units["P"] = pow(10, 15);
units["E"] = pow(10, 18);
for (std::map<std::string,long long>::iterator p = units.begin();
p != units.end(); ++p) {
// the upper bound of uint64_t is 2^64 = 4E
test_strict_sistrtoll_units("4", p->first, p->second);
test_strict_sistrtoll_units("1", p->first, p->second);
test_strict_sistrtoll_units("0", p->first, p->second);
}
}
TEST(SIStrToLL, WithoutUnits) {
test_strict_sistrtoll("1024");
test_strict_sistrtoll("1152921504606846976");
test_strict_sistrtoll("0");
}
static void test_strict_sistrtoll_err(const char *str)
{
std::string err;
strict_si_cast<uint64_t>(str, &err);
ASSERT_NE(err, "");
}
TEST(SIStrToLL, Error) {
test_strict_sistrtoll_err("1024F");
test_strict_sistrtoll_err("QDDSA");
test_strict_sistrtoll_err("1b");
test_strict_sistrtoll_err("100k");
test_strict_sistrtoll_err("1000m");
test_strict_sistrtoll_err("1g");
test_strict_sistrtoll_err("20t");
test_strict_sistrtoll_err("100p");
test_strict_sistrtoll_err("1000e");
test_strict_sistrtoll_err("B");
test_strict_sistrtoll_err("M");
test_strict_sistrtoll_err("BM");
test_strict_sistrtoll_err("B0wef");
test_strict_sistrtoll_err("0m");
test_strict_sistrtoll_err("-1"); // it returns uint64_t
test_strict_sistrtoll_err("-1K");
test_strict_sistrtoll_err("1Bi");
test_strict_sistrtoll_err("Bi");
test_strict_sistrtoll_err("bi");
test_strict_sistrtoll_err("gi");
test_strict_sistrtoll_err("100ki");
test_strict_sistrtoll_err("1000mi");
test_strict_sistrtoll_err("1gi");
test_strict_sistrtoll_err("20ti");
test_strict_sistrtoll_err("100pi");
test_strict_sistrtoll_err("1000ei");
test_strict_sistrtoll_err("1B");
// the upper bound of uint64_t is 2^64 = 4E, so 1024E overflows
test_strict_sistrtoll_err("1024E"); // overflows after adding the suffix
}
// since strict_sistrtoll is an alias of strict_si_cast<uint64_t>(), quite a few
// of cases are covered by existing test cases of strict_sistrtoll already.
TEST(StrictSICast, Error) {
{
std::string err;
// the SI prefix is way too large for `int`.
(void)strict_si_cast<int>("2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int>("-2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int>("1T", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("-2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("1T", &err);
ASSERT_EQ(err, "");
}
}
using ceph::parse;
using ceph::consume;
using namespace std::literals;
template<typename T>
inline void test_parse() {
auto r = parse<T>("23"sv);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 23);
r = parse<T>(" 23"sv);
EXPECT_FALSE(r);
r = parse<T>("-5"sv);
if constexpr (std::is_signed_v<T>) {
ASSERT_TRUE(r);
EXPECT_EQ(*r, -5);
} else {
EXPECT_FALSE(r);
}
r = parse<T>("meow"sv);
EXPECT_FALSE(r);
r = parse<T>("9yards"sv);
EXPECT_FALSE(r);
}
TEST(Parse, Char) {
test_parse<char>();
}
TEST(Parse, UChar) {
test_parse<unsigned char>();
}
TEST(Parse, SChar) {
test_parse<signed char>();
}
TEST(Parse, UInt8) {
test_parse<std::uint8_t>();
}
TEST(Parse, Int8) {
test_parse<std::int8_t>();
}
TEST(Parse, UInt16) {
test_parse<std::uint16_t>();
}
TEST(Parse, Int16) {
test_parse<std::int16_t>();
}
TEST(Parse, UInt32) {
test_parse<std::uint32_t>();
}
TEST(Parse, Int32) {
test_parse<std::int32_t>();
}
TEST(Parse, UInt64) {
test_parse<std::uint64_t>();
}
TEST(Parse, Int64) {
test_parse<std::int64_t>();
}
TEST(Parse, UIntMax) {
test_parse<std::uintmax_t>();
}
TEST(Parse, IntMax) {
test_parse<std::intmax_t>();
}
TEST(Parse, UIntPtr) {
test_parse<std::uintptr_t>();
}
TEST(Parse, IntPtr) {
test_parse<std::intptr_t>();
}
TEST(Parse, UShort) {
test_parse<unsigned short>();
}
TEST(Parse, Short) {
test_parse<short>();
}
TEST(Parse, ULong) {
test_parse<unsigned long>();
}
TEST(Parse, Long) {
test_parse<long>();
}
TEST(Parse, ULongLong) {
test_parse<unsigned long long>();
}
TEST(Parse, LongLong) {
test_parse<long long>();
}
template<typename T>
inline void test_consume() {
auto pos = "23"sv;
auto spacepos = " 23"sv;
auto neg = "-5"sv;
auto meow = "meow"sv;
auto trail = "9yards"sv;
auto v = pos;
auto r = consume<T>(v);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 23);
EXPECT_TRUE(v.empty());
v = spacepos;
r = consume<T>(v);
EXPECT_FALSE(r);
EXPECT_EQ(v, spacepos);
v = neg;
r = consume<T>(v);
if constexpr (std::is_signed_v<T>) {
ASSERT_TRUE(r);
EXPECT_EQ(*r, -5);
EXPECT_TRUE(v.empty());
} else {
EXPECT_FALSE(r);
EXPECT_EQ(v, neg);
}
v = meow;
r = consume<T>(v);
EXPECT_FALSE(r);
EXPECT_EQ(v, meow);
v = trail;
r = consume<T>(v);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 9);
auto w = trail;
w.remove_prefix(1);
EXPECT_EQ(v, w);
}
TEST(Consume, Char) {
test_consume<char>();
}
TEST(Consume, UChar) {
test_consume<unsigned char>();
}
TEST(Consume, SChar) {
test_consume<signed char>();
}
TEST(Consume, UInt8) {
test_consume<std::uint8_t>();
}
TEST(Consume, Int8) {
test_consume<std::int8_t>();
}
TEST(Consume, UInt16) {
test_consume<std::uint16_t>();
}
TEST(Consume, Int16) {
test_consume<std::int16_t>();
}
TEST(Consume, UInt32) {
test_consume<std::uint32_t>();
}
TEST(Consume, Int32) {
test_consume<std::int32_t>();
}
TEST(Consume, UInt64) {
test_consume<std::uint64_t>();
}
TEST(Consume, Int64) {
test_consume<std::int64_t>();
}
TEST(Consume, UIntMax) {
test_consume<std::uintmax_t>();
}
TEST(Consume, IntMax) {
test_consume<std::intmax_t>();
}
TEST(Consume, UIntPtr) {
test_consume<std::uintptr_t>();
}
TEST(Consume, IntPtr) {
test_consume<std::intptr_t>();
}
TEST(Consume, UShort) {
test_consume<unsigned short>();
}
TEST(Consume, Short) {
test_consume<short>();
}
TEST(Consume, ULong) {
test_consume<unsigned long>();
}
TEST(Consume, Long) {
test_consume<long>();
}
TEST(Consume, ULongLong) {
test_consume<unsigned long long>();
}
TEST(Consume, LongLong) {
test_consume<long long>();
}
/*
* Local Variables:
* compile-command: "cd .. ; make unittest_strtol && ./unittest_strtol"
* End:
*/
| 14,177 | 20.812308 | 82 |
cc
|
null |
ceph-main/src/test/test_addrs.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/types.h"
#include "include/stringify.h"
#include "msg/msg_types.h"
#include "gtest/gtest.h"
#include <sstream>
using namespace std;
// input, parsed+printed addr output, leftover
// if the parse fails, output + leftover should both be blank.
const char *addr_checks[][3] = {
{ "127.0.0.1", "v2:127.0.0.1:0/0", "" },
{ "127.0.0.1 foo", "v2:127.0.0.1:0/0", " foo" },
{ "127.0.0.1:1234 foo", "v2:127.0.0.1:1234/0", " foo" },
{ "127.0.0.1:1234/5678 foo", "v2:127.0.0.1:1234/5678", " foo" },
{ "1.2.3:4 a", "", "1.2.3:4 a" },
{ "2607:f298:4:2243::5522", "v2:[2607:f298:4:2243::5522]:0/0", "" },
{ "[2607:f298:4:2243::5522]", "v2:[2607:f298:4:2243::5522]:0/0", "" },
{ "2607:f298:4:2243::5522a", "", "2607:f298:4:2243::5522a" },
{ "[2607:f298:4:2243::5522]a", "v2:[2607:f298:4:2243::5522]:0/0", "a" },
{ "[2607:f298:4:2243::5522]:1234a", "v2:[2607:f298:4:2243::5522]:1234/0", "a" },
{ "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "v2:[2001:db8:85a3::8a2e:370:7334]:0/0", "" },
{ "2001:2db8:85a3:4334:4324:8a2e:1370:7334", "v2:[2001:2db8:85a3:4334:4324:8a2e:1370:7334]:0/0", "" },
{ "::", "v2:[::]:0/0", "" },
{ "::zz", "v2:[::]:0/0", "zz" },
{ ":: 12:34", "v2:[::]:0/0", " 12:34" },
{ "-", "-", "" },
{ "-asdf", "-", "asdf" },
{ "v1:1.2.3.4", "v1:1.2.3.4:0/0", "" },
{ "v1:1.2.3.4:12", "v1:1.2.3.4:12/0", "" },
{ "v1:1.2.3.4:12/34", "v1:1.2.3.4:12/34", "" },
{ "v2:1.2.3.4", "v2:1.2.3.4:0/0", "" },
{ "v2:1.2.3.4:12", "v2:1.2.3.4:12/0", "" },
{ "v2:1.2.3.4:12/34", "v2:1.2.3.4:12/34", "" },
{ NULL, NULL, NULL },
};
const char *addr_only_checks[][3] = {
// we shouldn't parse an addrvec...
{ "[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]", "", "[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]" },
{ NULL, NULL, NULL },
};
TEST(Msgr, TestAddrParsing)
{
for (auto& addr_checks : { addr_checks, addr_only_checks }) {
for (unsigned i = 0; addr_checks[i][0]; ++i) {
entity_addr_t a;
const char *end = "";
bool ok = a.parse(addr_checks[i][0], &end);
string out;
if (ok) {
stringstream ss;
ss << a;
getline(ss, out);
}
string left = end;
cout << "'" << addr_checks[i][0] << "' -> '" << out << "' + '" << left << "'" << std::endl;
ASSERT_EQ(out, addr_checks[i][1]);
ASSERT_EQ(left, addr_checks[i][2]);
if (addr_checks[i][0] == end) {
ASSERT_FALSE(ok);
} else {
ASSERT_TRUE(ok);
}
}
}
}
// check that legacy encoding to new decoding behaves
const char *addr_checks2[][3] = {
{ "v1:127.0.0.1", "v1:127.0.0.1:0/0", "" },
{ "v1:127.0.0.1 foo", "v1:127.0.0.1:0/0", " foo" },
{ "v1:127.0.0.1:1234 foo", "v1:127.0.0.1:1234/0", " foo" },
{ "v1:127.0.0.1:1234/5678 foo", "v1:127.0.0.1:1234/5678", " foo" },
{ "v1:2607:f298:4:2243::5522", "v1:[2607:f298:4:2243::5522]:0/0", "" },
{ "v1:[2607:f298:4:2243::5522]", "v1:[2607:f298:4:2243::5522]:0/0", "" },
{ "v1:[2607:f298:4:2243::5522]a", "v1:[2607:f298:4:2243::5522]:0/0", "a" },
{ "v1:[2607:f298:4:2243::5522]:1234a", "v1:[2607:f298:4:2243::5522]:1234/0", "a" },
{ "v1:2001:0db8:85a3:0000:0000:8a2e:0370:7334", "v1:[2001:db8:85a3::8a2e:370:7334]:0/0", "" },
{ "v1:2001:2db8:85a3:4334:4324:8a2e:1370:7334", "v1:[2001:2db8:85a3:4334:4324:8a2e:1370:7334]:0/0", "" },
{ "v1:1.2.3.4", "v1:1.2.3.4:0/0", "" },
{ "v1:1.2.3.4:12", "v1:1.2.3.4:12/0", "" },
{ "v1:1.2.3.4:12/34", "v1:1.2.3.4:12/34", "" },
{ NULL, NULL, NULL },
};
TEST(Msgr, TestAddrEncodeAddrvecDecode)
{
for (unsigned i = 0; addr_checks2[i][0]; ++i) {
entity_addr_t addr;
entity_addrvec_t addrvec;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
bufferlist bl;
addr.encode(bl, 0);
auto bli = bl.cbegin();
addrvec.decode(bli);
cout << addr_checks2[i][0] << " " << addr << " " << addrvec << std::endl;
ASSERT_EQ(addr, addrvec.v[0]);
if (addr_checks2[i][0] == end) {
ASSERT_FALSE(ok);
} else {
ASSERT_TRUE(ok);
}
}
}
TEST(Msgr, TestAddrvec0EncodeAddrDecode)
{
for (unsigned i = 0; addr_checks2[i][0]; ++i) {
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
entity_addr_t a;
a.decode(bli);
ASSERT_EQ(addr, a);
}
}
TEST(Msgr, TestEmptyAddrvecEncodeAddrDecode)
{
entity_addrvec_t addrvec;
entity_addr_t addr;
bufferlist bl;
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, entity_addr_t());
}
const char *addrvec_checks[][4] = {
{ "v1:1.2.3.4", "v2:1.2.3.4", "v1:1.2.3.4", "v2:1.2.3.4" },
{ "v2:1.2.3.5", "v1:1.2.3.5", "v1:1.2.3.5", "v2:1.2.3.5" },
{ "v2:1.2.3.6", "v2:1.2.3.6", "v1:1.2.3.6", "v2:1.2.3.6" },
{ "v2:1.2.3.7", "v1:1.2.3.7", "v1:1.2.3.7", "v2:1.2.3.7" },
{ NULL, NULL, NULL, NULL },
};
/*
* multiple addrs where one is legacy and others are not
* legacy addr is in position 0
*/
TEST(Msgr, TestAddrvecEncodeAddrDecode0)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][0]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][0], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, addrvec.v[0]);
}
/*
* multiple addrs where one is legacy and others are not
* legacy addr is not in position 0
*/
TEST(Msgr, TestAddrvecEncodeAddrDecode1)
{
entity_addr_t addr, a;
entity_addrvec_t addrvec;
bufferlist bl;
bool flag = true;
for (unsigned i = 0; addrvec_checks[i][1]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][1], &end);
ASSERT_TRUE(ok);
if (addr.type == entity_addr_t::TYPE_LEGACY && flag) {
a = addr;
flag = !flag;
}
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, a);
}
/* multiple legacy addrs */
TEST(Msgr, TestAddrvecEncodeAddrDecode2)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][2]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][2], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, addrvec.v[0]);
}
/* all non-legacy addrs */
TEST(Msgr, TestAddrvecEncodeAddrDecode3)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][3]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][3], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
//cout << addrvec << " (legacy " << addrvec.legacy_addr()
//<< ") -> " << addr << std::endl;
ASSERT_NE(addr, addrvec.v[0]); // it's not the first addr(which is non-legacy)
ASSERT_EQ(addr, entity_addr_t()); // it's not a blank addr either
}
const char *addrvec_parse_checks[][3] = {
{ "", "", "" },
{ "foo", "", "foo" },
{ " foo", "", " foo" },
{ "127.0.0.1", "v2:127.0.0.1:0/0", "" },
{ "127.0.0.1 foo", "v2:127.0.0.1:0/0", " foo" },
{ "[127.0.0.1]", "v2:127.0.0.1:0/0", "" },
{ "[127.0.0.1] foo", "v2:127.0.0.1:0/0", " foo" },
{ "127.0.0.1,::,- foo", "v2:127.0.0.1:0/0", ",::,- foo" },
{ "[127.0.0.1,::,-] foo", "[v2:127.0.0.1:0/0,v2:[::]:0/0,-]", " foo" },
{ "[127.0.0.1,::],- foo", "[v2:127.0.0.1:0/0,v2:[::]:0/0]", ",- foo" },
{ "[1.2.3.4,::,foo]", "", "[1.2.3.4,::,foo]" },
{ "[1.2.3.4,::,- foo", "", "[1.2.3.4,::,- foo" },
{ "[[::],1.2.3.4]", "[v2:[::]:0/0,v2:1.2.3.4:0/0]", "" },
{ "[::],1.2.3.4", "v2:[::]:0/0", ",1.2.3.4" },
{ NULL, NULL, NULL },
};
TEST(entity_addrvec_t, parse)
{
entity_addrvec_t addrvec;
for (auto v : { addr_checks, addr_checks2, addrvec_parse_checks }) {
for (unsigned i = 0; v[i][0]; ++i) {
const char *end = "";
bool ret = addrvec.parse(v[i][0], &end);
string out = stringify(addrvec);
string left = end;
cout << "'" << v[i][0] << "' -> '" << out << "' + '" << left << "'"
<< std::endl;
ASSERT_EQ(out, v[i][1]);
ASSERT_EQ(left, v[i][2]);
ASSERT_TRUE(out.empty() || ret);
}
}
}
TEST(entity_addrvec_t, legacy_equals)
{
entity_addr_t a1, a2;
ASSERT_TRUE(a1.parse("v1:1.2.3.4:567/890"));
ASSERT_TRUE(a2.parse("v2:1.2.3.4:567/890"));
entity_addrvec_t av1(a1);
entity_addrvec_t av21;
av21.v.push_back(a2);
av21.v.push_back(a1);
ASSERT_TRUE(av1.legacy_equals(av1));
ASSERT_TRUE(av21.legacy_equals(av21));
ASSERT_TRUE(av1.legacy_equals(av21));
ASSERT_TRUE(av21.legacy_equals(av1));
entity_addr_t b1, b2;
ASSERT_TRUE(b1.parse("v1:1.2.3.5:567/8"));
ASSERT_TRUE(b2.parse("v2:1.2.3.5:567/8"));
entity_addrvec_t bv1(b1);
entity_addrvec_t bv21;
bv21.v.push_back(b2);
bv21.v.push_back(b1);
ASSERT_TRUE(bv1.legacy_equals(bv21));
ASSERT_TRUE(bv21.legacy_equals(bv1));
ASSERT_FALSE(av1.legacy_equals(bv1));
ASSERT_FALSE(av21.legacy_equals(bv21));
ASSERT_FALSE(av21.legacy_equals(bv1));
ASSERT_FALSE(av1.legacy_equals(bv21));
}
| 9,731 | 28.050746 | 107 |
cc
|
null |
ceph-main/src/test/test_admin_socket_output.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <algorithm> // for move
#include <iostream> // for ostream
#include <memory> // for unique_ptr
#include <string> // for operator<<
#include <vector> // for vector
#include <boost/program_options/option.hpp> // for program_opt...
#include <boost/program_options/options_description.hpp> // for options_des...
#include <boost/program_options/parsers.hpp> // for basic_comma...
#include <boost/program_options/variables_map.hpp> // for variables_map
#include <boost/program_options/parsers.hpp> // for basic_comma...
#include "admin_socket_output.h"
#include "admin_socket_output_tests.h"
namespace po = boost::program_options;
void usage(po::options_description desc) {
std::cout << desc << std::endl;
}
void handle_unrecognised(std::vector<std::string>&& unrecognised) {
for (auto& un : unrecognised) {
std::cout << "Unrecognized Parameter: " << un << std::endl;
}
}
// Test functions:
// See admin_socket_output_tests.h
int main(int argc, char** argv) {
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("all", "implies"
" --osd"
" --mon"
" --mgr"
" --mds"
" --client"
" --vstart")
("osd", "Test osd admin socket output")
("mon", "Test mon admin socket output")
("mgr", "Test mgr admin socket output")
("mds", "Test mds admin socket output")
("client", "Test client (includes rgw) admin socket output")
("vstart", po::value<std::string>()->implicit_value("./out"),
"Modify to run in vstart environment")
;
auto parsed =
po::command_line_parser(argc, argv).options(desc).allow_unregistered().run();
po::variables_map vm;
po::store(parsed, vm);
po::notify(vm);
auto unrecognised = collect_unrecognized(parsed.options, po::include_positional);
if(!unrecognised.empty()) {
handle_unrecognised(std::move(unrecognised));
usage(desc);
return 1;
}
if (vm.count("help") || vm.empty()) {
usage(desc);
return 2;
}
std::unique_ptr<AdminSocketOutput> asockout(new AdminSocketOutput);
if (vm.count("vstart")) {
asockout->mod_for_vstart(vm["vstart"].as<std::string>());
}
if(vm.count("all")) {
asockout->add_target("all");
} else {
if (vm.count("osd")) {
asockout->add_target("osd");
}
if (vm.count("mon")) {
asockout->add_target("mon");
}
if (vm.count("mgr")) {
asockout->add_target("mgr");
}
if (vm.count("mds")) {
asockout->add_target("mds");
}
if (vm.count("client")) {
asockout->add_target("client");
}
}
// Postpone commands that may affect later commands
asockout->postpone("mds", "force_readonly");
// Custom commands
//Example:
//asockout->add_command("osd", R"({"prefix":"config get", "var":"admin_socket"})");
// End custom commands
// Tests
//Example:
//asockout->add_test("osd", R"({"prefix":"config get", "var":"admin_socket"})", test_config_get_admin_socket);
asockout->add_test("osd", R"({"prefix":"dump_pgstate_history"})", test_dump_pgstate_history);
// End tests
asockout->exec();
return 0;
}
| 3,766 | 27.976923 | 112 |
cc
|
null |
ceph-main/src/test/test_any.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2018 Adam C. Emerson <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <initializer_list>
#include <optional>
#include "gtest/gtest.h"
#include "include/any.h"
using std::optional;
using std::bad_any_cast;
using ceph::immobile_any;
using ceph::unique_any;
using ceph::shared_any;
using ceph::make_immobile_any;
using ceph::make_unique_any;
using ceph::make_shared_any;
using ceph::any_cast;
using std::swap;
template<typename A>
static void test_empty() {
A a;
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
a.reset();
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
}
TEST(Empty, Immobile) {
static_assert(std::is_nothrow_default_constructible_v<immobile_any<1024>>);
test_empty<immobile_any<1024>>();
}
TEST(Empty, Unique) {
static_assert(std::is_nothrow_default_constructible_v<unique_any>);
test_empty<unique_any>();
}
TEST(Empty, Shared) {
static_assert(std::is_nothrow_default_constructible_v<shared_any>);
test_empty<shared_any>();
}
struct cmd_tattler {
static thread_local bool copied;
static thread_local bool moved;
static thread_local bool destructed;
static void reset() {
copied = false;
moved = false;
destructed = false;
}
cmd_tattler() noexcept = default;
~cmd_tattler() noexcept {
if (destructed) {
std::terminate();
}
destructed = true;
}
cmd_tattler(const cmd_tattler&) noexcept {
if (copied) {
std::terminate();
}
copied = true;
}
cmd_tattler& operator =(const cmd_tattler&) noexcept {
if (copied) {
std::terminate();
}
copied = true;
return *this;
}
cmd_tattler(cmd_tattler&&) noexcept {
if (moved) {
std::terminate();
}
moved = true;
}
cmd_tattler& operator =(cmd_tattler&&) noexcept {
if (moved) {
std::terminate();
}
moved = true;
return *this;
}
};
thread_local bool cmd_tattler::copied = false;
thread_local bool cmd_tattler::moved = false;
thread_local bool cmd_tattler::destructed = false;
struct not_noexcept {
not_noexcept() = default;
not_noexcept(const not_noexcept&) noexcept(false) {
}
not_noexcept& operator =(const not_noexcept&) noexcept(false) {
return *this;
}
not_noexcept(not_noexcept&&) noexcept(false) {
}
not_noexcept& operator =(not_noexcept&&) noexcept(false) {
return *this;
}
template<typename ...Args>
explicit not_noexcept(Args&& ...) noexcept(false) {
}
template<typename U, typename ...Args>
not_noexcept(std::initializer_list<U>, Args&& ...) noexcept(false) {
}
};
template<typename A>
static void test_value_CMD() {
{
cmd_tattler::reset();
cmd_tattler c;
A a(c);
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = c;
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a = c;
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
{
cmd_tattler::reset();
cmd_tattler c;
A a(std::move(c));
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = std::move(c);
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a = std::move(c);
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = cmd_tattler{};
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
}
TEST(Value_CMD, Immobile) {
static_assert(std::is_nothrow_constructible_v<
immobile_any<1024>, const cmd_tattler&>);
static_assert(std::is_nothrow_assignable_v<
immobile_any<1024>, const cmd_tattler&>);
static_assert(std::is_nothrow_constructible_v<
immobile_any<1024>, cmd_tattler&&>);
static_assert(std::is_nothrow_assignable_v<
immobile_any<1024>, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
immobile_any<1024>, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
immobile_any<1024>, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
immobile_any<1024>, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
immobile_any<1024>, not_noexcept&&>);
test_value_CMD<immobile_any<1024>>();
}
TEST(Value_CMD, Unique) {
static_assert(!std::is_nothrow_constructible_v<
unique_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, not_noexcept&&>);
test_value_CMD<unique_any>();
}
TEST(Value_CMD, Shared) {
static_assert(!std::is_nothrow_constructible_v<
shared_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, not_noexcept&&>);
test_value_CMD<shared_any>();
}
template<typename A>
static void test_move() {
{
A a(5);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
A b(std::move(a));
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
A b(5);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
cmd_tattler::reset();
a = std::move(b);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(b.has_value());
EXPECT_EQ(typeid(void), b.type());
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
}
}
static_assert(!std::is_move_constructible_v<immobile_any<1024>>);
static_assert(!std::is_move_assignable_v<immobile_any<1024>>);
TEST(Move, Unique) {
static_assert(std::is_nothrow_move_constructible_v<unique_any>);
static_assert(std::is_nothrow_move_assignable_v<unique_any>);
test_move<unique_any>();
}
TEST(Move, Shared) {
static_assert(std::is_nothrow_move_constructible_v<shared_any>);
static_assert(std::is_nothrow_move_assignable_v<shared_any>);
test_move<shared_any>();
}
template<typename A>
static void test_copy() {
{
const A a(5);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
A b(a);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_EQ(any_cast<int>(a), any_cast<int>(b));
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
const A b(5);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
cmd_tattler::reset();
a = b;
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_EQ(any_cast<int>(a), any_cast<int>(b));
}
}
static_assert(!std::is_copy_constructible_v<immobile_any<1024>>);
static_assert(!std::is_copy_assignable_v<immobile_any<1024>>);
static_assert(!std::is_copy_constructible_v<unique_any>);
static_assert(!std::is_copy_assignable_v<unique_any>);
TEST(Copy, Shared) {
static_assert(std::is_nothrow_copy_constructible_v<shared_any>);
test_copy<shared_any>();
}
struct unmoving {
optional<int> a;
unmoving() noexcept {}
template<typename... Args>
explicit unmoving(Args&& ...args) noexcept
: a(sizeof...(Args)) {}
template<typename U, typename... Args>
explicit unmoving(std::initializer_list<U> l) noexcept
: a(-l.size()) {}
template<typename U, typename... Args>
unmoving(std::initializer_list<U> l, Args&& ...args) noexcept
: a(-l.size() * sizeof...(Args)) {}
unmoving(const unmoving&) = delete;
unmoving& operator =(const unmoving&) = delete;
unmoving(unmoving&&) = delete;
unmoving& operator =(unmoving&&) = delete;
};
template<typename A>
static void test_unmoving_pack_il() {
// Nothing!
{
const A a(std::in_place_type<unmoving>);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<unmoving&>(a).a);
}
// Pack!
{
const A a(std::in_place_type<unmoving>, nullptr, 5, 3.1);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>(nullptr, 5, 3.1);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(3, *any_cast<unmoving&>(a).a);
}
// List!
{
const A a(std::in_place_type<unmoving>, {true, true, true, true});
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>({true, true, true, true});
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(-4, *any_cast<unmoving&>(a).a);
}
// List + pack!!
{
const A a(std::in_place_type<unmoving>, {true, true, true, true},
nullptr, 5, 3.1);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>({true, true, true, true}, nullptr, 5, 3.1);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(-12, *any_cast<unmoving&>(a).a);
}
}
TEST(UmovingPackIl, Immobile) {
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>()));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<immobile_any<1024>>();
}
TEST(UmovingPackIl, Unique) {
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>()));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<unique_any>();
}
TEST(UmovingPackIl, Shared) {
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>()));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<shared_any>();
}
template<typename A>
static void test_swap() {
A a(true);
ASSERT_TRUE(a.has_value());
ASSERT_EQ(typeid(bool), a.type());
ASSERT_EQ(true, any_cast<bool>(a));
A b(5);
ASSERT_TRUE(b.has_value());
ASSERT_EQ(typeid(int), b.type());
ASSERT_EQ(5, any_cast<int>(b));
a.swap(b);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_EQ(5, any_cast<int>(a));
EXPECT_TRUE(b.has_value());
ASSERT_EQ(typeid(bool), b.type());
ASSERT_EQ(true, any_cast<bool>(b));
swap(a,b);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(bool), a.type());
EXPECT_EQ(true, any_cast<bool>(a));
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_EQ(5, any_cast<int>(b));
}
static_assert(!std::is_swappable_v<immobile_any<1024>>);
TEST(Swap, Unique) {
static_assert(std::is_nothrow_swappable_v<unique_any>);
test_swap<unique_any>();
}
TEST(Swap, Shared) {
static_assert(std::is_nothrow_swappable_v<shared_any>);
test_swap<shared_any>();
}
template<typename A>
static void test_cast() {
// Empty
{
A a;
EXPECT_EQ(nullptr, any_cast<int>(&a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<int&>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<int>(std::move(a));}, bad_any_cast);
EXPECT_THROW({any_cast<int&&>(std::move(a));}, bad_any_cast);
}
// Constant Empty
{
const A a{};
EXPECT_EQ(nullptr, any_cast<int>(const_cast<const A*>(&a)));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<const int&>(a);}, bad_any_cast);
}
// Filled!
{
A a(true);
EXPECT_TRUE(*any_cast<bool>(&a));
EXPECT_EQ(nullptr, any_cast<int>(&a));
EXPECT_TRUE(any_cast<bool>(a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<bool&>(a));
EXPECT_THROW({any_cast<int&>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<bool>(std::move(a)));
EXPECT_THROW({any_cast<int>(std::move(a));}, bad_any_cast);
EXPECT_TRUE(any_cast<bool&&>(std::move(a)));
EXPECT_THROW({any_cast<int&&>(std::move(a));}, bad_any_cast);
}
// Constant filled
{
const A a(true);
EXPECT_TRUE(*any_cast<const bool>(&a));
EXPECT_EQ(nullptr, any_cast<const int>(&a));
EXPECT_TRUE(any_cast<bool>(a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<const bool&>(a));
EXPECT_THROW({any_cast<const int&>(a);}, bad_any_cast);
}
// Move!
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
auto q = any_cast<cmd_tattler>(std::move(a));
EXPECT_TRUE(cmd_tattler::moved);
cmd_tattler::reset();
a.reset();
cmd_tattler::reset();
}
// Move! Again!
{
cmd_tattler::reset();
auto q = any_cast<cmd_tattler>(A(std::in_place_type<cmd_tattler>));
EXPECT_TRUE(cmd_tattler::moved);
cmd_tattler::reset();
}
}
TEST(Cast, Immobile) {
test_cast<immobile_any<1024>>();
}
TEST(Cast, Unique) {
test_cast<unique_any>();
}
TEST(Cast, Shared) {
test_cast<shared_any>();
}
TEST(Make, Immobile) {
// Nothing!
{
auto a{make_immobile_any<unmoving, 1024>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_immobile_any<unmoving, 1024>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_immobile_any<unmoving, 1024>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_immobile_any<unmoving, 1024>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
TEST(Make, Unique) {
// Nothing!
{
auto a{make_unique_any<unmoving>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_unique_any<unmoving>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_unique_any<unmoving>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_unique_any<unmoving>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
TEST(Make, Shared) {
// Nothing!
{
auto a{make_shared_any<unmoving>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_shared_any<unmoving>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_shared_any<unmoving>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_shared_any<unmoving>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
| 21,692 | 25.682657 | 77 |
cc
|
null |
ceph-main/src/test/test_arch.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2014 Red Hat <[email protected]>
*
* Author: Loic Dachary <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include "arch/probe.h"
#include "arch/intel.h"
#include "arch/arm.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#define FLAGS_SIZE 4096
TEST(Arch, all)
{
ceph_arch_probe();
EXPECT_TRUE(ceph_arch_probed);
#if (__arm__ || __aarch64__ || __x86_64__) && __linux__
char flags[FLAGS_SIZE];
FILE *f = popen("grep '^\\(flags\\|Features\\)[ ]*:' "
"/proc/cpuinfo | head -1", "r");
if(f == NULL || fgets(flags, FLAGS_SIZE - 1, f) == NULL) {
// silently do nothing if /proc/cpuinfo does exist, is not
// readable or does not contain the expected information
if (f)
pclose(f);
return;
}
pclose(f);
flags[strlen(flags) - 1] = ' ';
int expected;
#if (__arm__ || __aarch64__)
expected = (strstr(flags, " neon ") || strstr(flags, " asimd ")) ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_neon);
#endif
#if (__aarch64__)
expected = strstr(flags, " crc32 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_aarch64_crc32);
#endif
#if (__x86_64__)
expected = strstr(flags, " pclmulqdq ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_pclmul);
expected = strstr(flags, " sse4_2 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse42);
expected = strstr(flags, " sse4_1 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse41);
expected = (strstr(flags, " sse3 ") || strstr(flags, " ssse3 ") || strstr(flags, " pni ")) ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse3);
expected = strstr(flags, " ssse3 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_ssse3);
expected = strstr(flags, " sse2 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse2);
#endif
#endif
}
/*
* Local Variables:
* compile-command: "cd .. ; make -j4 &&
* make unittest_arch &&
* valgrind --tool=memcheck ./unittest_arch --gtest_filter=*.*"
* End:
*/
| 2,353 | 24.042553 | 101 |
cc
|
null |
ceph-main/src/test/test_auth.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/types.h"
#include "include/stringify.h"
#include "auth/Auth.h"
#include "gtest/gtest.h"
#include "common/ceph_context.h"
#include "global/global_context.h"
#include "auth/AuthRegistry.h"
#include <sstream>
TEST(AuthRegistry, con_modes)
{
auto cct = g_ceph_context;
AuthRegistry reg(cct);
std::vector<uint32_t> modes;
const std::vector<uint32_t> crc_secure = { CEPH_CON_MODE_CRC,
CEPH_CON_MODE_SECURE };
const std::vector<uint32_t> secure_crc = { CEPH_CON_MODE_SECURE,
CEPH_CON_MODE_CRC };
const std::vector<uint32_t> secure = { CEPH_CON_MODE_SECURE };
cct->_conf.set_val(
"enable_experimental_unrecoverable_data_corrupting_features", "*");
// baseline: everybody agrees
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "crc secure");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "crc secure");
cct->_conf.apply_changes(NULL);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
ASSERT_EQ((uint32_t)CEPH_CON_MODE_CRC, reg.pick_mode(CEPH_ENTITY_TYPE_OSD,
CEPH_AUTH_CEPHX,
crc_secure));
// what mons prefer secure, internal to mon cluster only
cct->_conf.set_val("ms_mon_cluster_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
/* mon/mgr are treated the same, and relevant config is ms_mon_cluster_mode */
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how all cluster -> mon connections secure?
cct->_conf.set_val("ms_mon_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about client -> mon connections?
cct->_conf.set_val("ms_mon_client_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// ms_mon)client_mode doesn't does't affect daemons, though...
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about all internal cluster connection secure?
cct->_conf.set_val("ms_cluster_mode", "secure");
cct->_conf.set_val("ms_mon_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MGR);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MDS);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about all connections to the cluster?
cct->_conf.set_val("ms_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MGR);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MDS);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// client forcing things?
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "secure");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// client *preferring* secure?
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "secure crc");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "secure crc");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
// back to normalish, for the benefit of the next test(s)
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
}
| 10,284 | 40.471774 | 80 |
cc
|
null |
ceph-main/src/test/test_backfill.sh
|
#!/bin/sh
TEST_POOL=rbd
./stop.sh
CEPH_NUM_OSD=3 ./vstart.sh -d -n -x -o 'osd min pg log entries = 5'
./rados -p $TEST_POOL bench 15 write -b 4096
./ceph osd out 0
./init-ceph stop osd.0
./ceph osd down 0
./rados -p $TEST_POOL bench 600 write -b 4096
| 255 | 20.333333 | 67 |
sh
|
null |
ceph-main/src/test/test_c2c.cc
|
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "common/config.h"
#include "global/global_init.h"
#include "global/signal_handler.h"
#include "include/mempool.h"
#include <iostream>
#include <string>
using std::cerr;
using std::string;
static void usage(void)
{
cerr << "--threads number of threads (default 1)" << std::endl;
cerr << "--sharding activate sharding optimization" << std::endl;
}
mempool::shard_t shards[mempool::num_shards] = {0};
void sigterm_handler(int signum)
{
size_t total = 0;
for (auto& shard : shards) {
total += shard.bytes;
}
std::cout << total << std::endl;
exit(0);
}
int main(int argc, const char **argv)
{
int ret = 0;
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
int threads = 1;
bool sharding = false;
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
}
else if (ceph_argparse_witharg(args, i, &threads, cerr, "--threads", "-t", (char*)NULL)) {
}
else if (ceph_argparse_flag(args, i, "--sharding", "-s", (char*)NULL)) {
sharding = true;
}
else {
cerr << "unknown command line option: " << *i << std::endl;
cerr << std::endl;
usage();
return 2;
}
}
init_async_signal_handler();
register_async_signal_handler(SIGTERM, sigterm_handler);
std::vector<std::thread> workers;
for (int i = 0; i < threads; i++) {
workers.push_back(
std::thread([&](){
while(1) {
size_t i;
if (sharding) {
i = mempool::pool_t::pick_a_shard_int();
} else {
i = 0;
}
shards[i].bytes++;
}
}));
}
for (auto& t:workers) {
t.join();
}
workers.clear();
return ret;
}
| 1,927 | 20.662921 | 94 |
cc
|
null |
ceph-main/src/test/test_c_headers.c
|
// -*- mode:C++; tab-width:2; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=2 sw=2 smarttab
#include <stdlib.h>
#include "include/cephfs/libcephfs.h"
#include "include/rados/librados.h"
#ifdef __cplusplus
#error "test invalid: only use C mode"
#endif
int main(int argc, char **argv)
{
int ret;
/* librados.h */
rados_t cluster;
ret = rados_create(&cluster, NULL);
if (ret < 0) {
return EXIT_FAILURE;
}
/* libcephfs.h */
struct ceph_mount_info *cmount;
ret = ceph_create(&cmount, NULL);
if (ret < 0) {
return EXIT_FAILURE;
}
return 0;
}
| 563 | 17.193548 | 70 |
c
|
null |
ceph-main/src/test/test_cfuse_cache_invalidate.cc
|
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "include/ceph_assert.h"
#define REGION 1048576
int main(int argc, char *argv[]) {
pid_t p = fork();
char buf[REGION];
memset(buf, 0, sizeof(buf));
if (p != 0) {
int done = 0;
int fd = open(argv[1], O_RDWR|O_CREAT, 0644);
if (fd < 0) {
perror(argv[1]);
return 1;
}
int i = 0;
while(!done) {
printf("writing %d\n", i++);
ceph_assert(pwrite(fd, buf, REGION, 0) == REGION);
int status;
int ret = waitpid(p, &status, WNOHANG);
ceph_assert(ret >= 0);
if (ret > 0) {
done = 1;
}
}
close(fd);
} else {
sleep(1);
int fd = open(argv[2], O_RDONLY, 0644);
if (fd < 0) {
perror(argv[2]);
return 1;
}
printf("reading\n");
ceph_assert(pread(fd, buf, REGION, 0) == REGION);
close(fd);
}
return 0;
}
| 1,005 | 17.290909 | 56 |
cc
|
null |
ceph-main/src/test/test_common.sh
|
#!/usr/bin/env bash
set -x
#
# test_common.sh
#
# Common routines for tests
#
#
# Environment variables that affect tests:
# KEEP_TEMPDIR If set, the tempdir will not be deleted
# when the test is over.
#
# Clean up the temporary directory
cleanup() {
if [ -n ${TEMPDIR} ]; then
rm -rf "${TEMPDIR}"
fi
}
# Create a temporary directory where test files will be stored.
setup_tempdir() {
TEMPDIR=`mktemp -d`
if [ -z $KEEP_TEMPDIR ]; then
trap cleanup INT TERM EXIT
fi
}
# Standard initialization function for tests
init() {
setup_tempdir
cd `dirname $0`/..
}
# Exit with an error message.
die() {
echo $@
exit 1
}
# Test that flag is set (the element is found in the list)
is_set()
{
local flag=$1; shift
local flags="$@"
local i
for i in ${flags}; do
if [ "${flag}" = "${i}" ]; then
return 0
fi
done
return 1
}
# Stop an OSD started by vstart
stop_osd() {
osd_index=$1
pidfile="out/osd.$osd_index.pid"
if [ -e $pidfile ]; then
if kill `cat $pidfile` ; then
poll_cmd "eval test -e $pidfile ; echo \$?" "1" 1 30
[ $? -eq 1 ] && return 0
echo "ceph-osd process did not terminate correctly"
else
echo "kill `cat $pidfile` failed"
fi
else
echo "ceph-osd process $osd_index is not running"
fi
return 1
}
# Restart an OSD started by vstart
restart_osd() {
osd_index=$1
./ceph-osd -i $osd_index -c ceph.conf &
}
# Ask the user a yes/no question and get the response
yes_or_no_choice() {
while true; do
echo -n "${1} [y/n] "
read ans
case "${ans}" in
y|Y|yes|YES|Yes) return 0 ;;
n|N|no|NO|No) return 1 ;;
*) echo "Please type yes or no."
echo ;;
esac
done
}
# Block until the user says "continue" or "c"
continue_prompt() {
prompt=${1:-"to go on"}
while true; do
echo "Please type 'c' or 'continue' ${prompt}."
read ans
case "${ans}" in
c|continue) return 0 ;;
*) echo ;;
esac
done
}
# Write a bunch of objects to rados
write_objects() {
start_ver=$1
stop_ver=$2
num_objs=$3
obj_size=$4
pool=$5
[ -d "${TEMPDIR}" ] || die "must setup_tempdir"
for v in `seq $start_ver $stop_ver`; do
chr=`perl -e "print chr(48+$v)"`
head -c $obj_size /dev/zero | tr '\0' "$chr" > $TEMPDIR/ver$v
for i in `seq -w 1 $num_objs`; do
./rados -c ./ceph.conf -p $pool put obj$i $TEMPDIR/ver$v || die "radostool failed"
done
done
}
read_objects() {
ver=$1
num_objs=$2
obj_size=$3
[ -d "${TEMPDIR}" ] || die "must setup_tempdir"
chr=`perl -e "print chr(48+$ver)"`
head -c $obj_size /dev/zero | tr '\0' "$chr" > $TEMPDIR/exemplar
for i in `seq -w 1 $num_objs`; do
./rados -c ./ceph.conf -p $pool get obj$i $TEMPDIR/out$i || die "radostool failed"
cmp $TEMPDIR/out$i $TEMPDIR/exemplar || die "got back incorrect obj$i"
done
}
poll_cmd() {
command=$1
search_str=$2
polling_interval=$3
total_time=$4
t=0
while [ $t -lt $total_time ]; do
$command | grep "$search_str"
[ $? -eq 0 ] && return 1
sleep $polling_interval
t=$(($t+$polling_interval))
done
return 0
}
dump_osd_store() {
set +x
echo "dumping osd store..."
find ./dev/osd* -type f | grep obj | grep head$ | sort | while read file; do
echo $file
head -c 10 $file
echo
done
}
start_recovery() {
CEPH_NUM_OSD=$1
osd=0
while [ $osd -lt $CEPH_NUM_OSD ]; do
./ceph -c ./ceph.conf tell osd.$osd debug kick_recovery_wq 0
osd=$((osd+1))
done
}
init
| 4,371 | 23.982857 | 106 |
sh
|
null |
ceph-main/src/test/test_cors.cc
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
extern "C"{
#include <curl/curl.h>
}
#include "common/ceph_crypto.h"
#include <map>
#include <list>
#define S3_BUCKET_NAME "s3testgw.fcgi"
#define SWIFT_BUCKET_NAME "swift3testgw.fcgi"
#define BUCKET_URL \
((g_test->get_key_type() == KEY_TYPE_S3)?(string("/" S3_BUCKET_NAME)):(string("/swift/v1/" SWIFT_BUCKET_NAME)))
#include <gtest/gtest.h>
#include "common/code_environment.h"
#include "common/ceph_argparse.h"
#include "common/Finisher.h"
#include "global/global_init.h"
#include "rgw_cors.h"
#include "rgw_cors_s3.h"
using namespace std;
#define CURL_VERBOSE 0
#define HTTP_RESPONSE_STR "RespCode"
#define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
extern "C" int ceph_armor(char *dst, const char *dst_end,
const char *src, const char *end);
enum key_type {
KEY_TYPE_UNDEFINED = 0,
KEY_TYPE_SWIFT,
KEY_TYPE_S3
};
static void print_usage(char *exec){
cout << "Usage: " << exec << " <Options>\n";
cout << "Options:\n"
"-g <gw-ip> - The ip address of the gateway\n"
"-p <gw-port> - The port number of the gateway\n"
"-k <SWIFT|S3> - The key type, either SWIFT or S3\n"
"-s3 <AWSAccessKeyId:SecretAccessKeyID> - Only, if the key type is S3, gives S3 credentials\n"
"-swift <Auth-Token> - Only if the key type is SWIFT, and gives the SWIFT credentials\n";
}
class test_cors_helper {
private:
string host;
string port;
string creds;
CURL *curl_inst;
map<string, string> response;
list<string> extra_hdrs;
string *resp_data;
unsigned resp_code;
key_type kt;
public:
test_cors_helper() : curl_inst(NULL), resp_data(NULL), resp_code(0), kt(KEY_TYPE_UNDEFINED){
curl_global_init(CURL_GLOBAL_ALL);
}
~test_cors_helper(){
curl_global_cleanup();
}
int send_request(string method, string uri,
size_t (*function)(void *,size_t,size_t,void *) = 0,
void *ud = 0, size_t length = 0);
int extract_input(unsigned argc, char *argv[]);
string& get_response(string hdr){
return response[hdr];
}
void set_extra_header(string hdr){
extra_hdrs.push_back(hdr);
}
void set_response(char *val);
void set_response_data(char *data, size_t len){
if(resp_data) delete resp_data;
resp_data = new string(data, len);
/*cout << resp_data->c_str() << "\n";*/
}
const string *get_response_data(){return resp_data;}
unsigned get_resp_code(){return resp_code;}
key_type get_key_type(){return kt;}
};
int test_cors_helper::extract_input(unsigned argc, char *argv[]){
#define ERR_CHECK_NEXT_PARAM(o) \
if((loop + 1) >= argc)return -1; \
else o = argv[loop+1];
for(unsigned loop = 1;loop < argc; loop += 2){
if(strcmp(argv[loop], "-g") == 0){
ERR_CHECK_NEXT_PARAM(host);
}else if(strcmp(argv[loop], "-k") == 0){
string type;
ERR_CHECK_NEXT_PARAM(type);
if(type.compare("S3") == 0)kt = KEY_TYPE_S3;
else if(type.compare("SWIFT") == 0)kt = KEY_TYPE_SWIFT;
}else if(strcmp(argv[loop],"-s3") == 0){
ERR_CHECK_NEXT_PARAM(creds);
}else if(strcmp(argv[loop],"-swift") == 0){
ERR_CHECK_NEXT_PARAM(creds);
}else if(strcmp(argv[loop],"-p") == 0){
ERR_CHECK_NEXT_PARAM(port);
}else return -1;
}
if(host.empty() || creds.empty())
return -1;
return 0;
}
void test_cors_helper::set_response(char *r){
string sr(r), h, v;
size_t off = sr.find(": ");
if(off != string::npos){
h.assign(sr, 0, off);
v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
}else{
/*Could be the status code*/
if(sr.find("HTTP/") != string::npos){
h.assign(HTTP_RESPONSE_STR);
off = sr.find(" ");
v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
resp_code = atoi((v.substr(0, 3)).c_str());
}
}
response[h] = v;
}
size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
test_cors_helper *h = static_cast<test_cors_helper *>(ud);
h->set_response((char *)ptr);
return size*nmemb;
}
size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
test_cors_helper *h = static_cast<test_cors_helper *>(ud);
h->set_response_data((char *)ptr, size*nmemb);
return size*nmemb;
}
static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
{
int i;
str[0] = '\0';
for (i = 0; i < len; i++) {
sprintf(&str[i*2], "%02x", (int)buf[i]);
}
}
static void calc_hmac_sha1(const char *key, int key_len,
const char *msg, int msg_len, char *dest)
/* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
{
ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
hmac.Update((const unsigned char *)msg, msg_len);
hmac.Final((unsigned char *)dest);
char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
}
static int get_s3_auth(const string &method, string creds, const string &date, const string &res, string& out){
string aid, secret, auth_hdr;
size_t off = creds.find(":");
out = "";
if(off != string::npos){
aid.assign(creds, 0, off);
secret.assign(creds, off + 1, string::npos);
/*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
char b64[65]; /* 64 is really enough */
auth_hdr.append(method + string("\n\n\n") + date + string("\n") + res);
calc_hmac_sha1(secret.c_str(), secret.length(), auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
if (ret < 0) {
cout << "ceph_armor failed\n";
return -1;
}
b64[ret] = 0;
out.append(aid + string(":") + b64);
}else return -1;
return 0;
}
void get_date(string& d){
struct timeval tv;
char date[64];
struct tm tm;
char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
(char *)"Wed", (char *)"Thu", (char *)"Fri",
(char *)"Sat"};
char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
(char *)"Apr", (char *)"May", (char *)"Jun",
(char *)"Jul",(char *) "Aug", (char *)"Sep",
(char *)"Oct", (char *)"Nov", (char *)"Dec"};
gettimeofday(&tv, NULL);
gmtime_r(&tv.tv_sec, &tm);
sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
days[tm.tm_wday],
tm.tm_mday, months[tm.tm_mon],
tm.tm_year + 1900,
tm.tm_hour, tm.tm_min, 0 /*tm.tm_sec*/);
d = date;
}
int test_cors_helper::send_request(string method, string res,
size_t (*read_function)( void *,size_t,size_t,void *),
void *ud,
size_t length){
string url;
string auth, date;
url.append(string("http://") + host);
if(port.length() > 0)url.append(string(":") + port);
url.append(res);
curl_inst = curl_easy_init();
if(curl_inst){
curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, write_header);
curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
if(read_function){
curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
}
get_date(date);
string http_date;
http_date.append(string("Date: ") + date);
if(kt == KEY_TYPE_S3){
string s3auth;
if(get_s3_auth(method, creds, date, res, s3auth) < 0)return -1;
auth.append(string("Authorization: AWS ") + s3auth);
} else if(kt == KEY_TYPE_SWIFT){
auth.append(string("X-Auth-Token: ") + creds);
} else {
cout << "Unknown state (" << kt << ")\n";
return -1;
}
struct curl_slist *slist = NULL;
slist = curl_slist_append(slist, auth.c_str());
slist = curl_slist_append(slist, http_date.c_str());
for(list<string>::iterator it = extra_hdrs.begin();
it != extra_hdrs.end(); ++it){
slist = curl_slist_append(slist, (*it).c_str());
}
if(read_function)
curl_slist_append(slist, "Expect:");
curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
response.erase(response.begin(), response.end());
extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
CURLcode res = curl_easy_perform(curl_inst);
if(res != CURLE_OK){
cout << "Curl perform failed for " << url << ", res: " <<
curl_easy_strerror(res) << "\n";
return -1;
}
curl_slist_free_all(slist);
}
curl_easy_cleanup(curl_inst);
return 0;
}
test_cors_helper *g_test;
Finisher *finisher;
static int create_bucket(void){
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("PUT"), string("/" S3_BUCKET_NAME));
if(g_test->get_resp_code() != 200U){
cout << "Error creating bucket, http code " << g_test->get_resp_code();
return -1;
}
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
g_test->send_request(string("PUT"), string("/swift/v1/" SWIFT_BUCKET_NAME));
if(g_test->get_resp_code() != 201U){
cout << "Error creating bucket, http code " << g_test->get_resp_code();
return -1;
}
}else return -1;
return 0;
}
static int delete_bucket(void){
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("DELETE"), string("/" S3_BUCKET_NAME));
if(g_test->get_resp_code() != 204U){
cout << "Error deleting bucket, http code " << g_test->get_resp_code();
return -1;
}
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
g_test->send_request(string("DELETE"), string("/swift/v1/" SWIFT_BUCKET_NAME));
if(g_test->get_resp_code() != 204U){
cout << "Error deleting bucket, http code " << g_test->get_resp_code();
return -1;
}
}else return -1;
return 0;
}
RGWCORSRule *xml_to_cors_rule(string s){
RGWCORSConfiguration_S3 *cors_config;
const DoutPrefix dp(g_ceph_context, 1, "test cors: ");
RGWCORSXMLParser_S3 parser(&dp, g_ceph_context);
const string *data = g_test->get_response_data();
if (!parser.init()) {
return NULL;
}
if (!parser.parse(data->c_str(), data->length(), 1)) {
return NULL;
}
cors_config = (RGWCORSConfiguration_S3 *)parser.find_first("CORSConfiguration");
if (!cors_config) {
return NULL;
}
return cors_config->host_name_rule(s.c_str());
}
size_t cors_read_xml(void *ptr, size_t s, size_t n, void *ud){
stringstream *ss = (stringstream *)ud;
size_t len = ss->str().length();
if(s*n < len){
cout << "Cannot copy xml data, as len is not enough\n";
return 0;
}
memcpy(ptr, (void *)ss->str().c_str(), len);
return len;
}
void send_cors(set<string> o, set<string> h,
list<string> e, uint8_t flags,
unsigned max_age){
if(g_test->get_key_type() == KEY_TYPE_S3){
RGWCORSRule rule(o, h, e, flags, max_age);
RGWCORSConfiguration config;
config.stack_rule(rule);
stringstream ss;
RGWCORSConfiguration_S3 *s3;
s3 = static_cast<RGWCORSConfiguration_S3 *>(&config);
s3->to_xml(ss);
g_test->send_request(string("PUT"), string("/" S3_BUCKET_NAME "?cors"), cors_read_xml,
(void *)&ss, ss.str().length());
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
set<string>::iterator it;
string a_o;
for(it = o.begin(); it != o.end(); ++it){
if(a_o.length() > 0)a_o.append(" ");
a_o.append(*it);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Allow-Origin: ") + a_o);
if(!h.empty()){
string a_h;
for(it = h.begin(); it != h.end(); ++it){
if(a_h.length() > 0)a_h.append(" ");
a_h.append(*it);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Allow-Headers: ") + a_h);
}
if(!e.empty()){
string e_h;
for(list<string>::iterator lit = e.begin(); lit != e.end(); ++lit){
if(e_h.length() > 0)e_h.append(" ");
e_h.append(*lit);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Expose-Headers: ") + e_h);
}
if(max_age != CORS_MAX_AGE_INVALID){
char age[32];
sprintf(age, "%u", max_age);
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Max-Age: ") + string(age));
}
//const char *data = "1";
stringstream ss;
ss << "1";
g_test->send_request(string("POST"), string("/swift/v1/" SWIFT_BUCKET_NAME), cors_read_xml,
(void *)&ss, 1);
}
}
TEST(TestCORS, getcors_firsttime){
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
g_test->send_request(string("GET"), string("/" S3_BUCKET_NAME "?cors"));
EXPECT_EQ(404U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_firsttime){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
/*Now get the CORS and check if its fine*/
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("GET"), string("/" S3_BUCKET_NAME "?cors"));
EXPECT_EQ(200U, g_test->get_resp_code());
RGWCORSRule *r = xml_to_cors_rule(string("example.com"));
EXPECT_TRUE(r != NULL);
if(!r)return;
EXPECT_TRUE((r->get_allowed_methods() & (RGW_CORS_GET | RGW_CORS_PUT))
== (RGW_CORS_GET | RGW_CORS_PUT));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_invalid_hostname){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
if((g_test->get_key_type() != KEY_TYPE_SWIFT)){
origins.insert(origins.end(), "");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_invalid_headers){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "www.example.com");
h.insert(h.end(), "*-Header-*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
h.erase(h.begin(), h.end());
if((g_test->get_key_type() != KEY_TYPE_SWIFT)){
h.insert(h.end(), "");
flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
h.erase(h.begin(), h.end());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_1){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: SomeHeader"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0U, s.length());
s = g_test->get_response(string("Access-Control-Max-Age"));
EXPECT_EQ(0U, s.length());
s = g_test->get_response(string("Access-Control-Expose-Headers"));
EXPECT_EQ(0U, s.length());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_2){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT | RGW_CORS_DELETE | RGW_CORS_HEAD;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
g_test->set_extra_header(string("Origin: foo.bar.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_3){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT | RGW_CORS_DELETE | RGW_CORS_HEAD;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
/*Check for HEAD in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
/*Check for DELETE in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: DELETE"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("DELETE"));
}
/*Check for PUT in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: PUT"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("PUT"));
}
/*Check for POST in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: POST"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
if(g_test->get_key_type() == KEY_TYPE_S3){
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0U, s.length());
}else{
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("POST"));
}
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_4){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
h.insert(h.end(), "Header1");
h.insert(h.end(), "Header2");
h.insert(h.end(), "*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0U, s.length());
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header2"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header2"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header2, Header1"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header2,Header1"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2, Header3"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2,Header3"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_5){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
e.insert(e.end(), "Expose1");
e.insert(e.end(), "Expose2");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Expose-Headers"));
EXPECT_EQ(0, s.compare("Expose1,Expose2"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_6){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
unsigned err = (g_test->get_key_type() == KEY_TYPE_SWIFT)?401U:403U;
origins.insert(origins.end(), "http://www.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
origins.insert(origins.end(), "*.example.com");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: .example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
origins.insert(origins.end(), "https://example*.com");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://example.a.b.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_7){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
h.insert(h.end(), "Header*");
h.insert(h.end(), "Hdr-*-Length");
h.insert(h.end(), "*-Length");
h.insert(h.end(), "foo*foo");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2, Header3, "
"Hdr--Length, Hdr-1-Length, Header-Length, Content-Length, foofoofoo"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2,Header3,"
"Hdr--Length,Hdr-1-Length,Header-Length,Content-Length,foofoofoo"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, deletecors_firsttime){
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
g_test->send_request("DELETE", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(204U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, deletecors_test){
set<string> origins, h;
list<string> e;
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
origins.insert(origins.end(), "example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->send_request("GET", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->send_request("DELETE", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(204U, g_test->get_resp_code());
g_test->send_request("GET", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(404U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
int main(int argc, char *argv[]){
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_test = new test_cors_helper();
finisher = new Finisher(g_ceph_context);
#ifdef GTEST
::testing::InitGoogleTest(&argc, argv);
#endif
finisher->start();
if(g_test->extract_input((unsigned)argc, argv) < 0){
print_usage(argv[0]);
return -1;
}
#ifdef GTEST
int r = RUN_ALL_TESTS();
if (r >= 0) {
cout << "There are failures in the test case\n";
return -1;
}
#endif
finisher->stop();
delete g_test;
delete finisher;
return 0;
}
| 34,226 | 36.945676 | 113 |
cc
|
null |
ceph-main/src/test/test_crush_bucket.sh
|
#!/usr/bin/env bash
#Generic test_crush_bucket test
#
# Includes
source $(dirname $0)/detect-build-env-vars.sh
source ../qa/standalone/ceph-helpers.sh
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:17119" # git grep '\<17119\>' : there must be only one
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
local funcs=${@:-$(set | ${SED} -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
$func $dir || return 1
done
}
function TEST_crush_bucket() {
local dir=$1
setup $dir || return 1
run_mon $dir a || return 1
run_osd $dir 0 || return 1
run_osd $dir 1 || return 1
run_osd $dir 2 || return 1
ceph osd getcrushmap -o "$dir/map1" || return 1
crushtool -d "$dir/map1" -o "$dir/map1.txt"|| return 1
local var=`ceph osd crush dump|grep -w id|grep '-'|grep -Eo '[0-9]+'|sort|uniq|${SED} -n '$p'`
local id=`expr $var + 1`
local item=`${SED} -n '/^root/,/}/p' $dir/map1.txt|grep 'item'|head -1`
local weight=`${SED} -n '/^root/,/}/p' $dir/map1.txt|grep 'item'|head -1|awk '{print $4}'`
local bucket="host test {\n id -$id\n # weight $weight\n alg straw \n hash 0 # rjenkins1 \n $item\n}\n"
${SED} -i "/# buckets/a\ $bucket" "$dir/map1.txt"
crushtool -c "$dir/map1.txt" -o "$dir/map1.bin" 2>"$dir/rev"
local result=$(cat "$dir/rev")
if [ "$result" != "" ];
then
return 1
fi
}
main testcrushbucket
| 1,516 | 27.622642 | 108 |
sh
|
null |
ceph-main/src/test/test_csyn.sh
|
#!/usr/bin/env bash
set -x
#
# Runs the synthetic client
#
# Includes
source "`dirname $0`/test_common.sh"
# Functions
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
# set recovery start to a really long time to ensure that we don't start recovery
./vstart.sh -d -n -o 'osd recovery delay start = 10000
osd max scrubs = 0' || die "vstart failed"
}
csyn_simple1_impl() {
./ceph-syn -c ./ceph.conf --syn writefile 100 1000 --syn writefile 100 1000 || die "csyn failed"
}
csyn_simple1() {
setup 2
csyn_simple1_impl
}
run() {
csyn_simple1 || die "test failed"
}
$@
| 633 | 16.135135 | 98 |
sh
|
null |
ceph-main/src/test/test_denc.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2016 Red Hat
*
* Author: Sage Weil <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include <numeric>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/denc.h"
using namespace std;
// test helpers
template<typename T>
void test_encode_decode(T v) {
bufferlist bl;
encode(v, bl);
auto p = bl.cbegin();
T out;
decode(out, p);
ASSERT_EQ(v, out);
}
template<typename T>
void test_denc(T v) {
// estimate
size_t s = 0;
denc(v, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(v, a);
}
ASSERT_LE(bl.length(), s);
// decode
bl.rebuild();
T out;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_EQ(v, out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
// test glue
test_encode_decode(v);
}
template<typename T>
void test_encode_decode_featured(T v) {
bufferlist bl;
encode(v, bl, 123);
auto p = bl.cbegin();
T out;
decode(out, p);
ASSERT_EQ(v, out);
}
template<typename T>
void test_denc_featured(T v) {
// estimate
size_t s = 0;
denc(v, s, 0);
ASSERT_GT(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(v, a, 1);
}
ASSERT_LE(bl.length(), s);
// decode
bl.rebuild();
T out;
auto bpi = bl.front().begin();
denc(out, bpi, 1);
ASSERT_EQ(v, out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
// test glue
test_encode_decode_featured(v);
}
// hooks to count bound calls
struct counts_t {
int num_bound_encode = 0;
int num_encode = 0;
int num_decode = 0;
void reset() {
num_bound_encode = 0;
num_encode = 0;
num_decode = 0;
}
} counts;
struct denc_counter_t {
void bound_encode(size_t& p) const {
++counts.num_bound_encode;
++p; // denc.h does not like 0-length objects
}
void encode(buffer::list::contiguous_appender& p) const {
p.append("a", 1);
++counts.num_encode;
}
void decode(buffer::ptr::const_iterator &p) {
p += 1;
++counts.num_decode;
}
};
WRITE_CLASS_DENC(denc_counter_t)
struct denc_counter_bounded_t {
void bound_encode(size_t& p) const {
++counts.num_bound_encode;
++p; // denc.h does not like 0-length objects
}
void encode(buffer::list::contiguous_appender& p) const {
p.append("a", 1);
++counts.num_encode;
}
void decode(buffer::ptr::const_iterator &p) {
p += 1;
++counts.num_decode;
}
};
WRITE_CLASS_DENC_BOUNDED(denc_counter_bounded_t)
TEST(denc, denc_counter)
{
denc_counter_t single, single2;
{
bufferlist bl;
encode(single, bl);
decode(single2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 1);
ASSERT_EQ(counts.num_decode, 1);
counts.reset();
}
TEST(denc, simple)
{
test_denc((uint8_t)4);
test_denc((int8_t)-5);
test_denc((uint16_t)6);
test_denc((int16_t)-7);
test_denc((uint32_t)8);
test_denc((int32_t)-9);
test_denc((uint64_t)10);
test_denc((int64_t)-11);
}
TEST(denc, string)
{
string a, b("hi"), c("multi\nline\n");
test_denc(a);
test_denc(b);
test_denc(c);
}
struct legacy_t {
int32_t a = 1;
void encode(bufferlist& bl) const {
using ceph::encode;
encode(a, bl);
}
void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(a, p);
}
legacy_t() {}
explicit legacy_t(int32_t i) : a(i) {}
friend bool operator<(const legacy_t& l, const legacy_t& r) {
return l.a < r.a;
}
friend bool operator==(const legacy_t& l, const legacy_t& r) {
return l.a == r.a;
}
};
WRITE_CLASS_ENCODER(legacy_t)
template<template<class> class C>
void test_common_veclist(const char* c) {
{
cout << c << "<std::string>" << std::endl;
C<std::string> s;
s.push_back("foo");
s.push_back("bar");
s.push_back("baz");
counts.reset();
test_denc(s);
}
{
cout << c << "<int32_t>" << std::endl;
C<int32_t> s;
s.push_back(1);
s.push_back(2);
s.push_back(3);
test_denc(s);
}
{
cout << c << "<legacy_t>" << std::endl;
C<legacy_t> s;
s.push_back(legacy_t(1));
s.push_back(legacy_t(2));
test_encode_decode(s);
}
}
// We only care about specializing the type, all other template
// parameters should have the default values. (Like first-class
// functions, first-class templates do not bring their defaults.)
template<typename T>
using default_vector = std::vector<T>;
TEST(denc, vector)
{
test_common_veclist<default_vector>("std::vector");
{
counts.reset();
vector<denc_counter_t> v, v2;
v.resize(100);
{
bufferlist bl;
encode(v, bl);
decode(v2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 100);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
{
counts.reset();
vector<denc_counter_bounded_t> v, v2;
v.resize(100);
{
bufferlist bl;
encode(v, bl);
decode(v2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
}
template<typename T>
using default_list = std::list<T>;
TEST(denc, list)
{
test_common_veclist<default_list>("std::list");
{
counts.reset();
list<denc_counter_bounded_t> l, l2;
for (unsigned i=0; i<100; ++i) {
l.emplace_back(denc_counter_bounded_t());
}
{
bufferlist bl;
encode(l, bl);
decode(l2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
}
template<template<class> class C>
void test_setlike(const char* c) {
{
cout << c << "<std::string>" << std::endl;
C<std::string> s;
s.insert("foo");
s.insert("bar");
s.insert("baz");
test_denc(s);
}
{
cout << c << "<int32_t>" << std::endl;
C<int32_t> s;
s.insert(1);
s.insert(2);
s.insert(3);
test_denc(s);
}
{
cout << c << "<legacy_t>" << std::endl;
C<legacy_t> s;
s.insert(legacy_t(1));
s.insert(legacy_t(2));
test_encode_decode(s);
}
}
template<typename T>
using default_set = std::set<T>;
TEST(denc, set)
{
test_setlike<default_set>("std::set");
}
template<typename T>
using default_flat_set= boost::container::flat_set<T>;
TEST(denc, flat_set)
{
test_setlike<default_flat_set>("std::set");
}
struct foo_t {
int32_t a = 0;
uint64_t b = 123;
DENC(foo_t, v, p) {
DENC_START(1, 1, p);
::denc(v.a, p);
::denc(v.b, p);
DENC_FINISH(p);
}
friend bool operator==(const foo_t& l, const foo_t& r) {
return l.a == r.a && l.b == r.b;
}
};
WRITE_CLASS_DENC_BOUNDED(foo_t)
struct foo2_t {
int32_t c = 0;
uint64_t d = 123;
DENC(foo2_t, v, p) {
DENC_START(1, 1, p);
::denc(v.c, p);
::denc(v.d, p);
DENC_FINISH(p);
}
friend bool operator==(const foo2_t& l, const foo2_t& r) {
return l.c == r.c && l.d == r.d;
}
};
WRITE_CLASS_DENC_BOUNDED(foo2_t)
struct bar_t {
int32_t a = 0;
uint64_t b = 123;
DENC_FEATURED(bar_t, v, p, f) {
::denc(v.a, p, f);
::denc(v.b, p, f);
}
friend bool operator==(const bar_t& l, const bar_t& r) {
return l.a == r.a && l.b == r.b;
}
};
WRITE_CLASS_DENC_FEATURED_BOUNDED(bar_t)
TEST(denc, foo)
{
foo_t a;
test_denc(a);
bufferlist bl;
encode(a, bl);
bl.hexdump(cout);
}
TEST(denc, bar)
{
bar_t a;
test_denc_featured(a);
}
TEST(denc, pair)
{
pair<int32_t,std::string> p;
bufferlist bl;
{
auto a = bl.get_contiguous_appender(1000);
denc(p, a);
encode(p, bl);
}
pair<int32_t,legacy_t> lp;
encode(lp, bl);
}
template<template<class, class> class C>
void test_common_maplike(const char* c) {
{
cout << c << "<std::string, foo_t>" << std::endl;
C<string, foo_t> s;
s["foo"] = foo_t();
s["bar"] = foo_t();
s["baz"] = foo_t();
test_denc(s);
}
{
cout << c << "<std::string, bar_t>" << std::endl;
C<string, bar_t> s;
s["foo"] = bar_t();
s["bar"] = bar_t();
s["baz"] = bar_t();
test_denc_featured(s);
}
{
cout << c << "<std::string, legacy_t>" << std::endl;
C<std::string, legacy_t> s;
s["foo"] = legacy_t(1);
s["bar"] = legacy_t(2);
test_encode_decode(s);
}
}
template<typename U, typename V>
using default_map = std::map<U, V>;
TEST(denc, map)
{
test_common_maplike<default_map>("std::map");
}
template<typename U, typename V>
using default_flat_map = boost::container::flat_map<U, V>;
TEST(denc, flat_map)
{
test_common_maplike<default_flat_map>("boost::container::flat_map");
}
TEST(denc, bufferptr_shallow_and_deep) {
// shallow encode
int32_t i = 1;
bufferptr p1("foo", 3);
bufferlist bl;
{
auto a = bl.get_contiguous_appender(100);
denc(i, a);
denc(p1, a);
denc(i, a);
}
cout << "bl is " << bl << std::endl;
bl.hexdump(cout);
ASSERT_EQ(3u, bl.get_num_buffers());
bufferlist bl2 = bl;
bl.rebuild();
bl2.rebuild();
// shallow decode
{
cout << "bl is " << bl << std::endl;
bl.hexdump(cout);
auto p = bl.front().begin();
bufferptr op;
int32_t i;
denc(i, p);
denc(op, p);
denc(i, p);
ASSERT_EQ(3u, op.length());
ASSERT_EQ('f', op[0]);
memset(bl.c_str(), 0, bl.length());
ASSERT_EQ(0, op[0]);
}
// deep decode
{
cout << "bl is " << bl2 << std::endl;
bl2.hexdump(cout);
auto p = bl2.front().begin_deep();
bufferptr op;
int32_t i;
denc(i, p);
denc(op, p);
denc(i, p);
ASSERT_EQ('f', op[0]);
memset(bl2.c_str(), 1, bl2.length());
ASSERT_EQ('f', op[0]);
}
}
TEST(denc, array)
{
{
cout << "std::array<std::string, 3>" << std::endl;
std::array<std::string, 3> s = { "foo", "bar", "baz" };
counts.reset();
test_denc(s);
}
{
cout << "std::array<uint32_t, 3>" << std::endl;
std::array<uint32_t, 3> s = { 1UL, 2UL, 3UL };
test_denc(s);
}
}
TEST(denc, tuple)
{
{
cout << "std::tuple<uint64_t, uint32_t>" << std::endl;
std::tuple<uint64_t, uint32_t> s(100ULL, 97UL);
counts.reset();
test_denc(s);
}
{
cout << "std::tuple<std::string, uint3_t>" << std::endl;
std::tuple<std::string, uint32_t> s("foo", 97);
test_denc(s);
}
{
cout << "std::tuple<std::string, std::set<uint32_t>>" << std::endl;
std::tuple<std::string, std::set<uint32_t>> s(
"bar", std::set<uint32_t>{uint32_t(1), uint32_t(2), uint32_t(3)});
test_denc(s);
}
}
TEST(denc, optional)
{
{
cout << "boost::optional<uint64_t>" << std::endl;
boost::optional<uint64_t> s = 97, t = boost::none;
counts.reset();
test_denc(s);
test_denc(t);
}
{
cout << "boost::optional<std::string>" << std::endl;
boost::optional<std::string> s = std::string("Meow"), t = boost::none;
counts.reset();
test_denc(s);
test_denc(t);
}
{
size_t s = 0;
denc(boost::none, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(boost::none, a);
}
ASSERT_LE(bl.length(), s);
bl.rebuild();
boost::optional<uint32_t> out = 5;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_FALSE(!!out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
}
}
TEST(denc, stdoptional)
{
{
cout << "std::optional<uint64_t>" << std::endl;
std::optional<uint64_t> s = 97, t = std::nullopt;
counts.reset();
test_denc(s);
test_denc(t);
}
{
cout << "std::optional<std::string>" << std::endl;
std::optional<std::string> s = std::string("Meow"), t = std::nullopt;
counts.reset();
test_denc(s);
test_denc(t);
}
{
size_t s = 0;
denc(std::nullopt, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(std::nullopt, a);
}
ASSERT_LE(bl.length(), s);
bl.rebuild();
std::optional<uint32_t> out = 5;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_FALSE(!!out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
}
}
// unlike legacy_t, Legacy supports denc() also.
struct Legacy {
static unsigned n_denc;
static unsigned n_decode;
uint8_t value = 0;
DENC(Legacy, v, p) {
n_denc++;
denc(v.value, p);
}
void decode(buffer::list::const_iterator& p) {
n_decode++;
using ceph::decode;
decode(value, p);
}
static void reset() {
n_denc = n_decode = 0;
}
static bufferlist encode_n(unsigned n, const vector<unsigned>& segments);
};
WRITE_CLASS_DENC(Legacy)
unsigned Legacy::n_denc = 0;
unsigned Legacy::n_decode = 0;
bufferlist Legacy::encode_n(unsigned n, const vector<unsigned>& segments) {
vector<Legacy> v;
for (unsigned i = 0; i < n; i++) {
v.push_back(Legacy());
}
bufferlist bl(n * sizeof(uint8_t));
using ceph::encode;
encode(v, bl);
bufferlist segmented;
auto p = bl.begin();
auto sum = std::accumulate(segments.begin(), segments.end(), 0u);
ceph_assert(sum != 0u);
for (auto i : segments) {
buffer::ptr seg;
p.copy_deep(bl.length() * i / sum, seg);
segmented.push_back(seg);
}
p.copy_all(segmented);
return segmented;
}
TEST(denc, no_copy_if_segmented_and_lengthy)
{
static_assert(_denc::has_legacy_denc<Legacy>::value,
"Legacy do have legacy denc");
{
// use denc() which shallow_copy() if the buffer is small
constexpr unsigned N_COPIES = 42;
const vector<unsigned> segs{50, 50}; // half-half
bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_LT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
vector<Legacy> v;
// denc() is shared by encode() and decode(), so reset() right before
// decode()
Legacy::reset();
decode(v, p);
ASSERT_EQ(N_COPIES, v.size());
ASSERT_EQ(N_COPIES, Legacy::n_denc);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use denc() which shallow_copy() if the buffer is not segmented and large
const unsigned N_COPIES = CEPH_PAGE_SIZE * 2;
const vector<unsigned> segs{100};
bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
ASSERT_EQ(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(N_COPIES, v.size());
ASSERT_EQ(N_COPIES, Legacy::n_denc);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use denc() which shallow_copy() if the buffer is segmented and large,
// but the total size of the chunks to be decoded is smallish.
bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
bufferlist small_bl = Legacy::encode_n(100, {50, 50});
bufferlist segmented;
segmented.append(large_bl);
segmented.append(small_bl);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
p += large_bl.length();
ASSERT_LT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(Legacy::n_denc, 100u);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use decode() which avoids deep copy if the buffer is segmented and large
bufferlist small_bl = Legacy::encode_n(100, {50, 50});
bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
bufferlist segmented;
segmented.append(small_bl);
segmented.append(large_bl);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
p += small_bl.length();
ASSERT_GT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(0u, Legacy::n_denc);
ASSERT_EQ(CEPH_PAGE_SIZE * 2, Legacy::n_decode);
}
}
| 16,370 | 21.004032 | 79 |
cc
|
null |
ceph-main/src/test/test_features.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <stdio.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "common/ceph_releases.h"
#include "common/ceph_strings.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/ceph_features.h"
using namespace std;
TEST(features, release_features)
{
for (int r = 1; r < CEPH_RELEASE_MAX; ++r) {
const char *name = ceph_release_name(r);
ASSERT_NE(string("unknown"), name);
ASSERT_EQ(ceph_release_t{static_cast<uint8_t>(r)},
ceph_release_from_name(name));
uint64_t features = ceph_release_features(r);
int rr = ceph_release_from_features(features);
cout << r << " " << name << " features 0x" << std::hex << features
<< std::dec << " looks like " << ceph_release_name(rr) << std::endl;
EXPECT_LE(rr, r);
}
}
TEST(features, release_from_features) {
ASSERT_EQ(CEPH_RELEASE_JEWEL, ceph_release_from_features(575862587619852283));
ASSERT_EQ(CEPH_RELEASE_LUMINOUS,
ceph_release_from_features(1152323339925389307));
}
int main(int argc, char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 1,433 | 28.875 | 80 |
cc
|
null |
ceph-main/src/test/test_get_blkdev_props.cc
|
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "include/uuid.h"
#include "common/blkdev.h"
#define BUFSIZE 80
int main(int argc, char **argv)
{
int fd, ret;
int64_t size;
bool discard_support;
bool rotational;
char dev[BUFSIZE];
char model[BUFSIZE];
char serial[BUFSIZE];
char wholedisk[BUFSIZE];
char partition[BUFSIZE];
if (argc != 2) {
fprintf(stderr, "usage: %s <blkdev>\n", argv[0]);
return -1;
}
fd = open(argv[1], O_RDONLY);
if (fd < 0) {
perror("open");
return -1;
}
BlkDev blkdev(fd);
if ((ret = blkdev.get_size(&size)) < 0) {
fprintf(stderr, "get_size: %s\n", strerror(-ret));
return -1;
}
discard_support = blkdev.support_discard();
rotational = blkdev.is_rotational();
if ((ret = blkdev.dev(dev, BUFSIZE)) < 0) {
fprintf(stderr, "dev: %s\n", strerror(-ret));
return -1;
}
if ((ret = blkdev.partition(partition, BUFSIZE)) < 0) {
fprintf(stderr, "partition: %s\n", strerror(-ret));
return -1;
}
if ((ret = blkdev.wholedisk(wholedisk, BUFSIZE)) < 0) {
fprintf(stderr, "wholedisk: %s\n", strerror(-ret));
return -1;
}
ret = blkdev.model(model, BUFSIZE);
if (ret == -ENOENT) {
snprintf(model, BUFSIZE, "unknown");
} else if (ret < 0) {
fprintf(stderr, "model: %s\n", strerror(-ret));
return -1;
}
ret = blkdev.serial(serial, BUFSIZE);
if (ret == -ENOENT) {
snprintf(serial, BUFSIZE, "unknown");
} else if (ret < 0) {
fprintf(stderr, "serial: %s\n", strerror(-ret));
return -1;
}
fprintf(stdout, "Size:\t\t%" PRId64 "\n", size);
fprintf(stdout, "Discard:\t%s\n",
discard_support ? "supported" : "not supported");
fprintf(stdout, "Rotational:\t%s\n", rotational ? "yes" : "no");
fprintf(stdout, "Dev:\t\t%s\n", dev);
fprintf(stdout, "Whole disk:\t%s\n", wholedisk);
fprintf(stdout, "Partition:\t%s\n", partition);
fprintf(stdout, "Model:\t\t%s\n", model);
fprintf(stdout, "Serial:\t\t%s\n", serial);
return 0;
}
| 2,018 | 21.433333 | 65 |
cc
|
null |
ceph-main/src/test/test_intarith.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <climits>
#include <gtest/gtest.h>
#include "include/intarith.h"
TEST(intarith, cbits) {
ASSERT_EQ(0u, cbits(0));
ASSERT_EQ(1u, cbits(1));
ASSERT_EQ(2u, cbits(2));
ASSERT_EQ(2u, cbits(3));
ASSERT_EQ(3u, cbits(4));
ASSERT_EQ(0u, cbits(0));
ASSERT_EQ(1u, cbits(1));
ASSERT_EQ(2u, cbits(2));
ASSERT_EQ(2u, cbits(3));
ASSERT_EQ(3u, cbits(4));
ASSERT_EQ(9u, cbits(0x100));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(64u, cbits(0xffffffffffffffff));
}
TEST(intarith, p2family) {
ASSERT_EQ(1024, p2align(1200, 1024));
ASSERT_EQ(1024, p2align(1024, 1024));
ASSERT_EQ(0x1200, p2align(0x1234, 0x100));
ASSERT_EQ(0x5600, p2align(0x5600, 0x100));
ASSERT_EQ(0x34, p2phase(0x1234, 0x100));
ASSERT_EQ(0x00, p2phase(0x5600, 0x100));
ASSERT_EQ(0xcc, p2nphase(0x1234, 0x100));
ASSERT_EQ(0x00, p2nphase(0x5600, 0x100));
ASSERT_EQ(0x1300, p2roundup(0x1234, 0x100));
ASSERT_EQ(0x5600, p2roundup(0x5600, 0x100));
}
| 1,128 | 26.536585 | 70 |
cc
|
null |
ceph-main/src/test/test_ipaddr.cc
|
#include "include/ipaddr.h"
#include "common/pick_address.h"
#include "gtest/gtest.h"
#include "include/stringify.h"
#include "common/ceph_context.h"
#include <boost/smart_ptr/intrusive_ptr.hpp>
#if defined(__FreeBSD__)
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#endif
#include <arpa/inet.h>
#include <ifaddrs.h>
#ifdef _WIN32
#include <ws2tcpip.h>
#else
#include <net/if.h>
#endif
using namespace std;
static void ipv4(struct sockaddr_in *addr, const char *s) {
int err;
addr->sin_family = AF_INET;
err = inet_pton(AF_INET, s, &addr->sin_addr);
ASSERT_EQ(1, err);
}
static void ipv6(struct sockaddr_in6 *addr, const char *s) {
int err;
addr->sin6_family = AF_INET6;
err = inet_pton(AF_INET6, s, &addr->sin6_addr);
ASSERT_EQ(1, err);
}
static char eth0[] = "eth0";
static char eth1[] = "eth1";
TEST(CommonIPAddr, TestNotFound)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv4(&net, "10.11.234.56");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 24));
ASSERT_FALSE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 24));
}
TEST(CommonIPAddr, TestV4_Simple)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv4(&net, "10.11.12.42");
ASSERT_TRUE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 24));
ASSERT_FALSE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 24));
}
TEST(CommonIPAddr, TestV4_Prefix25)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv4(&a_two, "10.11.12.129");
ipv4(&net, "10.11.12.128");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 25));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 25));
}
TEST(CommonIPAddr, TestV4_Prefix16)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv4(&net, "10.2.0.0");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 16));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 16));
}
TEST(CommonIPAddr, TestV4_PrefixTooLong)
{
struct ifaddrs one;
struct sockaddr_in a_one;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv4(&a_one, "10.11.12.13");
ipv4(&net, "10.11.12.12");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 42));
}
TEST(CommonIPAddr, TestV4_PrefixZero)
{
struct ifaddrs one, two;
struct sockaddr_in6 a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv4(&a_two, "10.1.2.3");
ipv4(&net, "255.0.1.2");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 0));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 0));
}
static char lo[] = "lo";
static char lo0[] = "lo:0";
TEST(CommonIPAddr, TestV4_SkipLoopback)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in a_three;
one.ifa_next = &two;
one.ifa_flags &= ~IFF_UP;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = lo;
two.ifa_next = &three;
two.ifa_flags = IFF_UP;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = lo0;
three.ifa_next = NULL;
three.ifa_flags = IFF_UP;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth0;
ipv4(&a_one, "127.0.0.1");
ipv4(&a_two, "127.0.0.1");
ipv4(&a_three, "10.1.2.3");
const struct sockaddr *result = nullptr;
// we prefer the non-loopback address despite the loopback addresses
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"", "");
ASSERT_EQ(three.ifa_addr, result);
// the subnet criteria leaves us no choice but the UP loopback address
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"127.0.0.0/8", "");
ASSERT_EQ(two.ifa_addr, result);
}
TEST(CommonIPAddr, TestV6_Simple)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv6(&net, "2001:1234:5678:90ab::dead:beef");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 64));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 64));
}
TEST(CommonIPAddr, TestV6_Prefix57)
{
struct ifaddrs one, two;
struct sockaddr_in6 a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv6(&net, "2001:1234:5678:90ab::dead:beef");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 57));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 57));
}
TEST(CommonIPAddr, TestV6_PrefixTooLong)
{
struct ifaddrs one;
struct sockaddr_in6 a_one;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv6(&net, "2001:1234:5678:900F::cdee");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 9000));
}
TEST(CommonIPAddr, TestV6_PrefixZero)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.2.3.4");
ipv6(&a_two, "2001:f00b::1");
ipv6(&net, "ff00::1");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 0));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 0));
}
TEST(CommonIPAddr, TestV6_SkipLoopback)
{
struct ifaddrs one, two, three;
struct sockaddr_in6 a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 a_three;
one.ifa_next = &two;
one.ifa_flags &= ~IFF_UP;
ipv6(&a_one, "::1");
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = lo;
two.ifa_next = &three;
two.ifa_flags = IFF_UP;
ipv6(&a_two, "::1");
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = lo0;
three.ifa_next = NULL;
three.ifa_flags = IFF_UP;
ipv6(&a_three, "2001:1234:5678:90ab::beef");
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth0;
const struct sockaddr *result = nullptr;
// we prefer the non-loopback address despite the loopback addresses
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"", "");
ASSERT_EQ(three.ifa_addr, result);
// the subnet criteria leaves us no choice but the UP loopback address
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"::1/128", "");
ASSERT_EQ(two.ifa_addr, result);
}
TEST(CommonIPAddr, ParseNetwork_Empty)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_Junk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_SlashNum)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("/24", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashNegative)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/-3", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashJunk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashNegative)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/-3", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashJunk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_0)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/0", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(0U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_13)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/13", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(13U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_32)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/32", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(32U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_42)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/42", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(42U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv6_0)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/0", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(0U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_67)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/67", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(67U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_128)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/128", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(128U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_9000)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/9000", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(9000U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ambiguous)
{
entity_addr_t a;
bool ok;
ok = a.parse("1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_ANY, a.get_type());
ok = a.parse("any:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_ANY, a.get_type());
ok = a.parse("v1:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_LEGACY, a.get_type());
ok = a.parse("v2:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_MSGR2, a.get_type());
}
TEST(CommonIPAddr, network_contains)
{
entity_addr_t network, addr;
unsigned int prefix;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/32", &network, &prefix);
ASSERT_TRUE(ok);
ASSERT_EQ(32U, prefix);
ok = addr.parse("2001:1234:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_TRUE(network_contains(network, prefix, addr));
ok = addr.parse("2001:1334:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("127.0.0.1", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = parse_network("10.1.2.3/16", &network, &prefix);
ASSERT_TRUE(ok);
ASSERT_EQ(16U, prefix);
ok = addr.parse("2001:1234:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("1.2.3.4", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("10.1.22.44", nullptr);
ASSERT_TRUE(ok);
ASSERT_TRUE(network_contains(network, prefix, addr));
ok = addr.parse("10.2.22.44", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
}
TEST(pick_address, find_ip_in_subnet_list)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in6 a_three;
const struct sockaddr *result;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = &three;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
three.ifa_next = NULL;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv6(&a_three, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
// match by network
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.1.0.0/16",
"eth0");
ASSERT_EQ(one.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.2.0.0/16",
"eth1");
ASSERT_EQ(two.ifa_addr, result);
// match by eth name
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.0.0.0/8",
"eth0");
ASSERT_EQ(one.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.0.0.0/8",
"eth1");
ASSERT_EQ(two.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV6,
"2001::/16",
"eth1");
ASSERT_EQ(three.ifa_addr, result);
}
TEST(pick_address, filtering)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in6 a_three;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = &three;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
three.ifa_next = NULL;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv6(&a_three, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:0.0.0.0:0/0"), stringify(av.v[0]));
}
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:[::]:0/0"), stringify(av.v[0]));
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
}
{
cct->_conf.set_val("public_network", "10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
cct->_conf.set_val("cluster_network", "10.1.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("cluster_network", "");
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
cct->_conf.set_val("cluster_network", "10.1.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_CLUSTER |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:10.1.1.2:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("cluster_network", "");
}
{
cct->_conf.set_val("public_network", "2001::/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
}
{
cct->_conf.set_val("public_network", "2001::/16 10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "2001::/16 10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_PREFER_IPV4,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v1:10.2.1.123:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "2001::/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
}
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:0.0.0.0:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:0.0.0.0:0/0"), stringify(av.v[1]));
}
}
TEST(pick_address, ipv4_ipv6_enabled)
{
struct ifaddrs one;
struct sockaddr_in a_one;
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv4(&a_one, "10.1.1.2");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "10.1.1.0/24");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
cct->_conf.set_val("ms_bind_ipv6", "true");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(-1, r);
}
}
TEST(pick_address, ipv4_ipv6_enabled2)
{
struct ifaddrs one;
struct sockaddr_in6 a_one;
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv6(&a_one, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "2001::/16");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
cct->_conf.set_val("ms_bind_ipv6", "true");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(-1, r);
}
}
| 27,288 | 26.343687 | 109 |
cc
|
null |
ceph-main/src/test/test_lost.sh
|
#!/usr/bin/env bash
set -x
#
# Test the lost object logic
#
# Includes
source "`dirname $0`/test_common.sh"
TEST_POOL=rbd
# Functions
setup() {
export CEPH_NUM_OSD=$1
vstart_config=$2
# Start ceph
./stop.sh
# set recovery start to a really long time to ensure that we don't start recovery
./vstart.sh -d -n -o "$vstart_config" || die "vstart failed"
# for exiting pools set size not greater than number of OSDs,
# so recovery from degraded ps is possible
local changed=0
for pool in `./ceph osd pool ls`; do
local size=`./ceph osd pool get ${pool} size | awk '{print $2}'`
if [ "${size}" -gt "${CEPH_NUM_OSD}" ]; then
./ceph osd pool set ${pool} size ${CEPH_NUM_OSD} --yes-i-really-mean-it
changed=1
fi
done
if [ ${changed} -eq 1 ]; then
# XXX: When a pool has degraded pgs due to size greater than number
# of OSDs, after decreasing the size the recovery still could stuck
# and requires an additional kick.
./ceph osd out 0
./ceph osd in 0
fi
poll_cmd "./ceph health" HEALTH_OK 1 30
}
recovery1_impl() {
# Write lots and lots of objects
write_objects 1 1 200 4000 $TEST_POOL
# Take down osd1
stop_osd 1
# Continue writing a lot of objects
write_objects 2 2 200 4000 $TEST_POOL
# Bring up osd1
restart_osd 1
# Finish peering.
sleep 15
# Stop osd0.
# At this point we have peered, but *NOT* recovered.
# Objects should be lost.
stop_osd 0
poll_cmd "./ceph pg debug degraded_pgs_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see degraded PGs."
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see unfound objects."
echo "Got unfound objects."
restart_osd 0
sleep 20
start_recovery 2
# Turn on recovery and wait for it to complete.
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 3 120
[ $? -eq 1 ] || die "Failed to recover unfound objects."
poll_cmd "./ceph pg debug degraded_pgs_exist" FALSE 3 120
[ $? -eq 1 ] || die "Recovery never finished."
}
recovery1() {
setup 2 'osd recovery delay start = 10000'
recovery1_impl
}
lost1_impl() {
local flags="$@"
local lost_action=delete
local pgs_unfound pg
if is_set revert_lost $flags; then
lost_action=revert
fi
# Write lots and lots of objects
write_objects 1 1 20 8000 $TEST_POOL
# Take down osd1
stop_osd 1
# Continue writing a lot of objects
write_objects 2 2 20 8000 $TEST_POOL
# Bring up osd1
restart_osd 1
# Finish peering.
sleep 15
# Stop osd0.
# At this point we have peered, but *NOT* recovered.
# Objects should be lost.
stop_osd 0
# Since recovery can't proceed, stuff should be unfound.
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see unfound objects."
pgs_unfound=`./ceph health detail |awk '$1 = "pg" && /[0-9] unfound$/ {print $2}'`
[ -n "$pgs_unfound" ] || die "no pg with unfound objects"
for pg in $pgs_unfound; do
./ceph pg $pg mark_unfound_lost revert &&
die "mark_unfound_lost unexpectedly succeeded for pg $pg"
done
if ! is_set mark_osd_lost $flags && ! is_set rm_osd $flags; then
return
fi
if is_set try_to_fetch_unfound $flags; then
# Ask for an object while it's still unfound, and
# verify we get woken to an error when it's declared lost.
echo "trying to get one of the unfound objects"
(
./rados -c ./ceph.conf -p $TEST_POOL get obj02 $TEMPDIR/obj02 &&\
die "expected radostool error"
) &
fi
if is_set mark_osd_lost $flags; then
./ceph osd lost 0 --yes-i-really-mean-it
fi
if is_set rm_osd $flags; then
./ceph osd rm 0
fi
if ! is_set auto_mark_unfound_lost $flags; then
for pg in $pgs_unfound; do
./ceph pg $pg mark_unfound_lost ${lost_action} ||
die "mark_unfound_lost failed for pg $pg"
done
fi
start_recovery 2
# Unfound objects go away and are turned into lost objects.
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 3 120
[ $? -eq 1 ] || die "Unfound objects didn't go away."
for pg in `ceph pg ls | awk '/^[0-9]/ {print $1}'`; do
./ceph pg $pg mark_unfound_lost revert 2>&1 |
grep 'pg has no unfound objects' ||
die "pg $pg has unfound objects"
done
# Reading from a lost object gives back an error code.
# TODO: check error code
./rados -c ./ceph.conf -p $TEST_POOL get obj01 $TEMPDIR/obj01
if [ lost_action = delete -a $? -eq 0 ]; then
die "expected radostool error"
elif [ lost_action = revert -a $? -ne 0 ]; then
die "unexpected radostool error"
fi
if is_set try_to_fetch_unfound $flags; then
echo "waiting for the try_to_fetch_unfound \
radostool instance to finish"
wait
fi
}
lost1() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost revert_lost
}
lost2() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost try_to_fetch_unfound
}
lost3() {
setup 2 'osd recovery delay start = 10000'
lost1_impl rm_osd
}
lost4() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost rm_osd
}
lost5() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost auto_mark_unfound_lost
}
all_osds_die_impl() {
poll_cmd "./ceph osd stat" '3 up, 3 in' 20 240
[ $? -eq 1 ] || die "didn't start 3 osds"
stop_osd 0
stop_osd 1
stop_osd 2
# wait for the MOSDPGStat timeout
poll_cmd "./ceph osd stat" '0 up' 20 240
[ $? -eq 1 ] || die "all osds weren't marked as down"
}
all_osds_die() {
setup 3 'osd mon report interval = 3
mon osd report timeout = 60'
all_osds_die_impl
}
run() {
recovery1 || die "test failed"
lost1 || die "test failed"
# XXX: try_to_fetch_unfound test currently hangs on "waiting for the
# try_to_fetch_unfound radostool instance to finish"
#lost2 || die "test failed"
lost3 || die "test failed"
lost4 || die "test failed"
# XXX: automatically marking lost is not implemented
#lost5 || die "test failed"
all_osds_die || die "test failed"
}
if [ -z "$@" ]; then
run
echo OK
exit 0
fi
$@
| 6,419 | 23.883721 | 89 |
sh
|
null |
ceph-main/src/test/test_mempool.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2016 Western Digital Corporation
*
* Author: Allen Samuels <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/btree_map.h"
#include "include/mempool.h"
using namespace std;
void check_usage(mempool::pool_index_t ix)
{
mempool::pool_t *pool = &mempool::get_pool(ix);
mempool::stats_t total;
map<std::string,mempool::stats_t> m;
pool->get_stats(&total, &m);
size_t usage = pool->allocated_bytes();
size_t sum = 0;
for (auto& p : m) {
sum += p.second.bytes;
}
if (sum != usage) {
ceph::TableFormatter jf;
pool->dump(&jf);
jf.flush(std::cout);
}
EXPECT_EQ(sum, usage);
}
template<typename A, typename B>
void eq_elements(const A& a, const B& b)
{
auto lhs = a.begin();
auto rhs = b.begin();
while (lhs != a.end()) {
EXPECT_EQ(*lhs,*rhs);
lhs++;
rhs++;
}
EXPECT_EQ(rhs,b.end());
}
template<typename A, typename B>
void eq_pairs(const A& a, const B& b)
{
auto lhs = a.begin();
auto rhs = b.begin();
while (lhs != a.end()) {
EXPECT_EQ(lhs->first,rhs->first);
EXPECT_EQ(lhs->second,rhs->second);
lhs++;
rhs++;
}
EXPECT_EQ(rhs,b.end());
}
#define MAKE_INSERTER(inserter) \
template<typename A,typename B> \
void do_##inserter(A& a, B& b, int count, int base) { \
for (int i = 0; i < count; ++i) { \
a.inserter(base + i); \
b.inserter(base + i); \
} \
}
MAKE_INSERTER(push_back);
MAKE_INSERTER(insert);
template<typename A,typename B>
void do_insert_key(A& a, B& b, int count, int base)
{
for (int i = 0; i < count; ++i) {
a.insert(make_pair(base+i,base+i));
b.insert(make_pair(base+i,base+i));
check_usage(mempool::osd::id);
}
}
TEST(mempool, vector_context)
{
check_usage(mempool::osd::id);
EXPECT_EQ(mempool::osd::allocated_bytes(), 0u);
EXPECT_EQ(mempool::osd::allocated_items(), 0u);
for (unsigned i = 0; i < 10; ++i) {
vector<int> a;
mempool::osd::vector<int> b,c;
eq_elements(a,b);
do_push_back(a,b,i,i);
eq_elements(a,b);
check_usage(mempool::osd::id);
mempool::stats_t total;
map<std::string,mempool::stats_t> by_type;
mempool::get_pool(mempool::osd::id).get_stats(&total, &by_type);
EXPECT_GE(mempool::osd::allocated_bytes(), i * 4u);
EXPECT_GE(mempool::osd::allocated_items(), i);
c.swap(b);
eq_elements(a,c);
check_usage(mempool::osd::id);
a.clear();
b.clear();
c.clear();
}
}
TEST(mempool, list_context)
{
for (unsigned i = 1; i < 10; ++i) {
list<int> a;
mempool::osd::list<int> b,c;
eq_elements(a,b);
do_push_back(a,b,i,i);
eq_elements(a,b);
c.swap(b);
eq_elements(a,c);
a.erase(a.begin());
c.erase(c.begin());
eq_elements(a,c);
a.clear();
b.clear();
c.clear();
do_push_back(a,b,i,i);
c.splice(c.begin(),b,b.begin(),b.end());
mempool::stats_t total;
map<std::string,mempool::stats_t> by_type;
mempool::get_pool(mempool::osd::id).get_stats(&total, &by_type);
EXPECT_GE(mempool::osd::allocated_bytes(), i * 4u);
EXPECT_EQ(mempool::osd::allocated_items(), i);
eq_elements(a,c);
check_usage(mempool::osd::id);
}
}
TEST(mempool, set_context)
{
for (int i = 0; i < 10; ++i) {
set<int> a;
mempool::osd::set<int> b;
do_insert(a,b,i,i);
eq_elements(a,b);
check_usage(mempool::osd::id);
}
for (int i = 1; i < 10; ++i) {
set<int> a;
mempool::osd::set<int> b;
do_insert(a,b,i,0);
EXPECT_NE(a.find(i/2),a.end());
EXPECT_NE(b.find(i/2),b.end());
a.erase(a.find(i/2));
b.erase(b.find(i/2));
eq_elements(a,b);
check_usage(mempool::osd::id);
}
}
struct obj {
MEMPOOL_CLASS_HELPERS();
int a;
int b;
obj() : a(1), b(1) {}
explicit obj(int _a) : a(_a), b(2) {}
obj(int _a,int _b) : a(_a), b(_b) {}
friend inline bool operator<(const obj& l, const obj& r) {
return l.a < r.a;
}
};
MEMPOOL_DEFINE_OBJECT_FACTORY(obj, obj, osdmap);
TEST(mempool, test_factory)
{
obj *o1 = new obj();
obj *o2 = new obj(10);
obj *o3 = new obj(20,30);
check_usage(mempool::osdmap::id);
EXPECT_NE(o1,nullptr);
EXPECT_EQ(o1->a,1);
EXPECT_EQ(o1->b,1);
EXPECT_EQ(o2->a,10);
EXPECT_EQ(o2->b,2);
EXPECT_EQ(o3->a,20);
EXPECT_EQ(o3->b,30);
delete o1;
delete o2;
delete o3;
check_usage(mempool::osdmap::id);
}
TEST(mempool, vector)
{
{
mempool::osd::vector<int> v;
v.push_back(1);
v.push_back(2);
}
{
mempool::osdmap::vector<obj> v;
v.push_back(obj());
v.push_back(obj(1));
}
}
TEST(mempool, set)
{
mempool::osd::set<int> set_int;
set_int.insert(1);
set_int.insert(2);
mempool::osdmap::set<obj> set_obj;
set_obj.insert(obj());
set_obj.insert(obj(1));
set_obj.insert(obj(1, 2));
}
TEST(mempool, map)
{
{
mempool::osd::map<int,int> v;
v[1] = 2;
v[3] = 4;
}
{
mempool::osdmap::map<int,obj> v;
v[1] = obj();
v[2] = obj(2);
v[3] = obj(2, 3);
}
}
TEST(mempool, list)
{
{
mempool::osd::list<int> v;
v.push_back(1);
v.push_back(2);
}
{
mempool::osdmap::list<obj> v;
v.push_back(obj());
v.push_back(obj(1));
}
}
TEST(mempool, dump)
{
ostringstream ostr;
Formatter* f = Formatter::create("xml-pretty", "xml-pretty", "xml-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("html-pretty", "html-pretty", "html-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("table", "table", "table");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("json-pretty", "json-pretty", "json-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
}
TEST(mempool, unordered_map)
{
mempool::osdmap::unordered_map<int,obj> h;
h[1] = obj();
h[2] = obj(1);
}
TEST(mempool, string_test)
{
mempool::osdmap::string s;
s.reserve(100);
EXPECT_GE(mempool::osdmap::allocated_items(), s.capacity() + 1u); // +1 for zero-byte termination :
for (size_t i = 0; i < 10; ++i) {
s += '1';
s.append(s);
EXPECT_GE(mempool::osdmap::allocated_items(), s.capacity() + 1u);
}
}
TEST(mempool, bufferlist)
{
bufferlist bl;
int len = 1048576;
size_t before = mempool::buffer_anon::allocated_bytes();
cout << "before " << before << std::endl;
bl.append(buffer::create_aligned(len, 4096));
size_t after = mempool::buffer_anon::allocated_bytes();
cout << "after " << after << std::endl;
ASSERT_GE(after, before + len);
}
TEST(mempool, bufferlist_reassign)
{
bufferlist bl;
size_t items_before = mempool::buffer_anon::allocated_items();
size_t bytes_before = mempool::buffer_anon::allocated_bytes();
bl.append("fooo");
ASSERT_EQ(items_before + 1, mempool::buffer_anon::allocated_items());
ASSERT_LT(bytes_before, mempool::buffer_anon::allocated_bytes());
// move existing bl
bl.reassign_to_mempool(mempool::mempool_osd);
ASSERT_EQ(items_before, mempool::buffer_anon::allocated_items());
ASSERT_EQ(bytes_before, mempool::buffer_anon::allocated_bytes());
// additional appends should go to the same pool
items_before = mempool::osd::allocated_items();
bytes_before = mempool::osd::allocated_bytes();
cout << "anon b " << mempool::buffer_anon::allocated_bytes() << std::endl;
for (unsigned i = 0; i < 1000; ++i) {
bl.append("asdfddddddddddddddddddddddasfdasdfasdfasdfasdfasdf");
}
cout << "anon a " << mempool::buffer_anon::allocated_bytes() << std::endl;
ASSERT_LT(items_before, mempool::osd::allocated_items());
ASSERT_LT(bytes_before, mempool::osd::allocated_bytes());
// try_.. won't
items_before = mempool::osd::allocated_items();
bytes_before = mempool::osd::allocated_bytes();
bl.try_assign_to_mempool(mempool::mempool_bloom_filter);
ASSERT_EQ(items_before, mempool::osd::allocated_items());
ASSERT_EQ(bytes_before, mempool::osd::allocated_bytes());
}
TEST(mempool, bufferlist_c_str)
{
bufferlist bl;
int len = 1048576;
size_t before = mempool::osd::allocated_bytes();
bl.append(buffer::create_aligned(len, 4096));
bl.append(buffer::create_aligned(len, 4096));
bl.reassign_to_mempool(mempool::mempool_osd);
size_t after = mempool::osd::allocated_bytes();
ASSERT_GE(after, before + len * 2);
bl.c_str();
size_t after_c_str = mempool::osd::allocated_bytes();
ASSERT_EQ(after, after_c_str);
}
TEST(mempool, btree_map_test)
{
typedef mempool::pool_allocator<mempool::mempool_osd,
pair<const uint64_t,uint64_t>> allocator_t;
typedef btree::btree_map<uint64_t,uint64_t,std::less<uint64_t>,allocator_t> btree_t;
{
btree_t btree;
ASSERT_EQ(0, mempool::osd::allocated_items());
ASSERT_EQ(0, mempool::osd::allocated_bytes());
for (size_t i = 0; i < 1000; ++i) {
btree[rand()] = rand();
}
ASSERT_LT(0, mempool::osd::allocated_items());
ASSERT_LT(0, mempool::osd::allocated_bytes());
}
ASSERT_EQ(0, mempool::osd::allocated_items());
ASSERT_EQ(0, mempool::osd::allocated_bytes());
}
TEST(mempool, check_shard_select)
{
const size_t samples = mempool::num_shards * 100;
std::atomic_int shards[mempool::num_shards] = {0};
std::vector<std::thread> workers;
for (size_t i = 0; i < samples; i++) {
workers.push_back(
std::thread([&](){
size_t i = mempool::pool_t::pick_a_shard_int();
shards[i]++;
}));
}
for (auto& t:workers) {
t.join();
}
workers.clear();
size_t missed = 0;
for (size_t i = 0; i < mempool::num_shards; i++) {
if (shards[i] == 0) {
missed++;
}
}
// If more than half of the shards did not get anything,
// the distribution is bad enough to deserve a failure.
EXPECT_LT(missed, mempool::num_shards / 2);
}
int main(int argc, char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
// enable debug mode for the tests
mempool::set_debug_mode(true);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
/*
* Local Variables:
* compile-command: "cd ../../build ; make -j4 &&
* make unittest_mempool &&
* valgrind --tool=memcheck ./unittest_mempool --gtest_filter=*.*"
* End:
*/
| 11,258 | 23.422993 | 101 |
cc
|
null |
ceph-main/src/test/test_missing_unfound.sh
|
#!/bin/sh
CEPH_NUM_OSD=3 ./vstart.sh -d -n -x -o 'osd recovery max active = 1'
TEST_POOL=rbd
./ceph -c ./ceph.conf osd pool set $TEST_POOL size 3
sleep 20
./init-ceph stop osd.1
./ceph osd down 1 # faster
for f in `seq 1 100`
do
./rados -c ./ceph.conf -p $TEST_POOL put test_$f /etc/passwd
done
# zap some objects on both replicas
#rm dev/osd[02]/current/*/test_40*
# some on only one
rm dev/osd0/current/*/test_*
#rm dev/osd2/current/*/test_6*
# ...and see how we fare!
./init-ceph start osd.1
| 512 | 16.1 | 68 |
sh
|
null |
ceph-main/src/test/test_mutate.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
/*
* Test Ioctx::operate
*/
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "common/config.h"
#include "global/global_init.h"
#include "include/rados/librados.hpp"
#include "include/types.h"
#include <errno.h>
#include <iostream>
#include <string>
using std::cerr;
using std::string;
using namespace librados;
static void usage(void)
{
cerr << "--oid set object id to 'operate' on" << std::endl;
cerr << "--pool set pool to 'operate' on" << std::endl;
}
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
string val;
string oid("ceph_test_object");
string pool_name("test_pool");
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
}
else if (ceph_argparse_witharg(args, i, &val, "--oid", "-o", (char*)NULL)) {
oid = val;
}
else if (ceph_argparse_witharg(args, i, &val, "--pool", "-p", (char*)NULL)) {
pool_name = val;
}
else {
cerr << "unknown command line option: " << *i << std::endl;
cerr << std::endl;
usage();
return 2;
}
}
Rados rados;
if (rados.init_with_context(g_ceph_context) < 0) {
cerr << "couldn't initialize rados!" << std::endl;
return 1;
}
if (rados.conf_read_file(NULL) < 0) {
cerr << "failed to read rados configuration file!" << std::endl;
return 1;
}
if (rados.connect() < 0) {
cerr << "couldn't connect to cluster!" << std::endl;
return 1;
}
int ret = 0;
librados::ObjectWriteOperation o;
IoCtx ioctx;
if (rados.pool_lookup(pool_name.c_str()) <= 0) {
ret = rados.pool_create(pool_name.c_str());
if (ret) {
cerr << "failed to create pool named '" << pool_name
<< "': error " << ret << std::endl;
return 1;
}
}
ret = rados.ioctx_create(pool_name.c_str(), ioctx);
if (ret) {
cerr << "failed to create ioctx for pool '" << pool_name
<< "': error " << ret << std::endl;
return 1;
}
ioctx.application_enable("rados", true);
librados::ObjectWriteOperation op;
op.create(true);
ret = ioctx.operate(oid, &op);
if (ret) {
cerr << "ioctx.operate failed: ret = " << ret << std::endl;
return 1;
}
return 0;
}
| 2,870 | 24.40708 | 81 |
cc
|
null |
ceph-main/src/test/test_objectstore_memstore.sh
|
#!/bin/sh -ex
rm -rf memstore.test_temp_dir
ceph_test_objectstore --gtest_filter=\*/0
echo OK
| 96 | 12.857143 | 41 |
sh
|
null |
ceph-main/src/test/test_pageset.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "gtest/gtest.h"
#include "os/memstore/PageSet.h"
template <typename T>
bool is_aligned(T* ptr) {
const auto align_mask = alignof(T) - 1;
return (reinterpret_cast<uintptr_t>(ptr) & align_mask) == 0;
}
TEST(PageSet, AllocAligned)
{
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(1u, range[1]->offset);
ASSERT_EQ(2u, range[2]->offset);
ASSERT_EQ(3u, range[3]->offset);
// verify that the Page pointers are properly aligned
ASSERT_TRUE(is_aligned(range[0].get()));
ASSERT_TRUE(is_aligned(range[1].get()));
ASSERT_TRUE(is_aligned(range[2].get()));
ASSERT_TRUE(is_aligned(range[3].get()));
}
TEST(PageSet, AllocUnaligned)
{
PageSet pages(2);
PageSet::page_vector range;
// front of first page
pages.alloc_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page
pages.alloc_range(1, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page and front of second
pages.alloc_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page and all of second
pages.alloc_range(1, 3, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page, all of second, and front of third
pages.alloc_range(1, 4, range);
ASSERT_EQ(3u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(4u, range[2]->offset);
}
TEST(PageSet, GetAligned)
{
// allocate 4 pages
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
range.clear();
// get first page
pages.get_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// get second and third pages
pages.get_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// get all four pages
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(1u, range[1]->offset);
ASSERT_EQ(2u, range[2]->offset);
ASSERT_EQ(3u, range[3]->offset);
range.clear();
}
TEST(PageSet, GetUnaligned)
{
// allocate 3 pages
PageSet pages(2);
PageSet::page_vector range;
pages.alloc_range(0, 6, range);
range.clear();
// front of first page
pages.get_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page
pages.get_range(1, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page and front of second
pages.get_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page and all of second
pages.get_range(1, 3, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page, all of second, and front of third
pages.get_range(1, 4, range);
ASSERT_EQ(3u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(4u, range[2]->offset);
range.clear();
// back of third page with nothing beyond
pages.get_range(5, 999, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(4u, range[0]->offset);
range.clear();
}
TEST(PageSet, GetHoles)
{
// allocate pages at offsets 1, 2, 5, and 7
PageSet pages(1);
PageSet::page_vector range;
for (uint64_t i : {1, 2, 5, 7})
pages.alloc_range(i, 1, range);
range.clear();
// nothing at offset 0, page at offset 1
pages.get_range(0, 2, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(1u, range[0]->offset);
range.clear();
// nothing at offset 0, pages at offset 1 and 2, nothing at offset 3
pages.get_range(0, 4, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// page at offset 2, nothing at offset 3 or 4
pages.get_range(2, 3, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(2u, range[0]->offset);
range.clear();
// get the full range
pages.get_range(0, 999, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(5u, range[2]->offset);
ASSERT_EQ(7u, range[3]->offset);
range.clear();
}
TEST(PageSet, FreeAligned)
{
// allocate 4 pages
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
range.clear();
// get the full range
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free after offset 4 has no effect
pages.free_pages_after(4);
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 4
pages.free_pages_after(3);
pages.get_range(0, 4, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free pages 2 and 3
pages.free_pages_after(1);
pages.get_range(0, 4, range);
ASSERT_EQ(1u, range.size());
range.clear();
}
TEST(PageSet, FreeUnaligned)
{
// allocate 4 pages
PageSet pages(2);
PageSet::page_vector range;
pages.alloc_range(0, 8, range);
range.clear();
// get the full range
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free after offset 7 has no effect
pages.free_pages_after(7);
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 4
pages.free_pages_after(5);
pages.get_range(0, 8, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free pages 2 and 3
pages.free_pages_after(1);
pages.get_range(0, 8, range);
ASSERT_EQ(1u, range.size());
range.clear();
}
TEST(PageSet, FreeHoles)
{
// allocate pages at offsets 1, 2, 5, and 7
PageSet pages(1);
PageSet::page_vector range;
for (uint64_t i : {1, 2, 5, 7})
pages.alloc_range(i, 1, range);
range.clear();
// get the full range
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 7
pages.free_pages_after(6);
pages.get_range(0, 8, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free page 5
pages.free_pages_after(3);
pages.get_range(0, 8, range);
ASSERT_EQ(2u, range.size());
range.clear();
// free pages 1 and 2
pages.free_pages_after(0);
pages.get_range(0, 8, range);
ASSERT_EQ(0u, range.size());
}
| 6,808 | 22.975352 | 70 |
cc
|
null |
ceph-main/src/test/test_pidfile.sh
|
#!/usr/bin/env bash
#
# test pidfile here
#
# Includes
source $(dirname $0)/detect-build-env-vars.sh
source $CEPH_ROOT/qa/standalone/ceph-helpers.sh
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:7124" # git grep '\<7124\>' : there must be only one
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
local funcs=${@:-$(set | sed -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
$func $dir || return 1
done
}
function TEST_without_pidfile() {
local dir=$1
setup $dir
local data=$dir/osd1
local id=1
ceph-mon \
--id $id \
--mkfs \
--mon-data=$data \
--run-dir=$dir || return 1
expect_failure $dir "ignore empty --pid-file" ceph-mon \
-f \
--log-to-stderr \
--log_flush_on_exit \
--pid-file= \
--id $id \
--mon-data=$data \
--run-dir=$dir || return 1
teardown $dir
}
function TEST_pidfile() {
local dir=$1
setup $dir
# no daemon can use a pidfile that is owned by another daemon
run_mon $dir a || return 1
sleep 5
run_mon $dir a --log-to-stderr -f 2>&1 | grep "failed to lock pidfile" || return 1
run_osd $dir 0 || return 1
sleep 5
activate_osd $dir 0 --log-to-stderr -f 2>&1 | grep "failed to lock pidfile" || return 1
# when a daemon shutdown, it will not unlink a path different from
# the one it owns
mv $dir/osd.0.pid $dir/osd.0.pid.old || return 1
cp $dir/osd.0.pid.old $dir/osd.0.pid || return 1
kill_daemons $dir TERM osd.0 || return 1
test -f $dir/osd.0.pid || return 1
# when a daemon starts, it re-uses the pid file if no other daemon
# has it locked
run_osd $dir 0 || return 1
! cmp $dir/osd.0.pid $dir/osd.0.pid.old || return 1
# if the pid in the file is different from the pid of the daemon
# the file is not removed because it is assumed to be owned by
# another daemon
mkdir $dir/old
cp $dir/osd.0.pid $dir/old/osd.0.pid # so that kill_daemon finds the pid
echo 123 > $dir/osd.0.pid
kill_daemons $dir/old TERM osd.0 || return 1
test -f $dir/osd.0.pid || return 1
# when the daemon shutdown, it removes its own pid file
test -f $dir/mon.a.pid || return 1
kill_daemons $dir TERM mon.a || return 1
! test -f $dir/mon.a.pid || return 1
teardown $dir || return 1
}
main pidfile "$@"
| 2,479 | 26.252747 | 91 |
sh
|
null |
ceph-main/src/test/test_pools.sh
|
#!/usr/bin/env bash
set -x
#
# Test pools
#
# Includes
source "`dirname $0`/test_common.sh"
# Functions
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
./vstart.sh -d -n || die "vstart failed"
}
test629_impl() {
# create the pool
./ceph -c ./ceph.conf osd pool create foo 8 || die "pool create failed"
# Write lots and lots of objects
write_objects 1 1 10 1000000 foo
# Take down first osd
stop_osd 0
# Now degraded PGs should exist
poll_cmd "./ceph pg debug degraded_pgs_exist" TRUE 3 120
# delete the pool
./ceph -c ./ceph.conf osd pool rm foo foo --yes-i-really-really-mean-it || die "pool rm failed"
# make sure the system is stable
sleep 10
}
test629(){
setup 3
test629_impl
}
run() {
test629 || die "test failed"
}
$@
| 898 | 16.627451 | 103 |
sh
|
null |
ceph-main/src/test/test_rados_tool.sh
|
../../qa/workunits/rados/test_rados_tool.sh
| 43 | 43 | 43 |
sh
|
null |
ceph-main/src/test/test_random_string.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/random_string.h"
#include "common/ceph_context.h"
#include "global/global_context.h"
#include <gtest/gtest.h>
inline bool is_alphanumeric_lower(char c) {
return std::islower(c) || std::isdigit(c);
}
inline bool is_alphanumeric_upper(char c) {
return std::isupper(c) || std::isdigit(c);
}
inline bool is_alphanumeric_plain(char c) {
return std::islower(c) || std::isupper(c) || std::isdigit(c);
}
inline bool is_alphanumeric_no_underscore(char c) {
return is_alphanumeric_plain(c) || c == '-' || c == '.';
}
inline bool is_alphanumeric(char c) {
return is_alphanumeric_plain(c) || c == '-' || c == '_';
}
inline bool is_base64(char c) {
return is_alphanumeric_plain(c) || c == '+' || c == '/';
}
TEST(RandomString, base64)
{
char arr[65] = {};
ASSERT_EQ(0, gen_rand_base64(g_ceph_context, arr, sizeof(arr)));
EXPECT_EQ(0, arr[64]); // must be null terminated
EXPECT_TRUE(std::all_of(arr, arr + 64, is_base64));
}
TEST(RandomString, alphanumeric)
{
char arr[65] = {};
gen_rand_alphanumeric(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric));
}
TEST(RandomString, alphanumeric_string)
{
std::string str = gen_rand_alphanumeric(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric));
}
TEST(RandomString, alphanumeric_lower)
{
char arr[65] = {};
gen_rand_alphanumeric_lower(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_lower));
}
TEST(RandomString, alphanumeric_lower_string)
{
std::string str = gen_rand_alphanumeric_lower(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_lower));
}
TEST(RandomString, alphanumeric_upper)
{
char arr[65] = {};
gen_rand_alphanumeric_upper(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_upper));
}
TEST(RandomString, alphanumeric_upper_string)
{
std::string str = gen_rand_alphanumeric_upper(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_upper));
}
TEST(RandomString, alphanumeric_no_underscore)
{
char arr[65] = {};
gen_rand_alphanumeric_no_underscore(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_no_underscore));
}
TEST(RandomString, alphanumeric_no_underscore_string)
{
std::string str = gen_rand_alphanumeric_no_underscore(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_no_underscore));
}
TEST(RandomString, alphanumeric_plain)
{
char arr[65] = {};
gen_rand_alphanumeric_plain(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_plain));
}
TEST(RandomString, alphanumeric_plain_string)
{
std::string str = gen_rand_alphanumeric_plain(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_plain));
}
| 3,587 | 28.652893 | 82 |
cc
|
null |
ceph-main/src/test/test_rbd_replay.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2014 Adam Crume <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/escape.h"
#include "gtest/gtest.h"
#include <stdint.h>
#include <boost/foreach.hpp>
#include <cstdarg>
#include "rbd_replay/ImageNameMap.hpp"
#include "rbd_replay/ios.hpp"
#include "rbd_replay/rbd_loc.hpp"
namespace rbd_replay {
std::ostream& operator<<(std::ostream& o, const rbd_loc& name) {
return o << "('" << name.pool << "', '" << name.image << "', '" << name.snap << "')";
}
}
using namespace rbd_replay;
static void add_mapping(ImageNameMap *map, std::string mapping_string) {
ImageNameMap::Mapping mapping;
if (!map->parse_mapping(mapping_string, &mapping)) {
ASSERT_TRUE(false) << "Failed to parse mapping string '" << mapping_string << "'";
}
map->add_mapping(mapping);
}
TEST(RBDReplay, ImageNameMap) {
ImageNameMap m;
add_mapping(&m, "x@y=y@x");
add_mapping(&m, "a\\=b@c=h@i");
add_mapping(&m, "a@b\\=c=j@k");
add_mapping(&m, "a\\@b@c=d@e");
add_mapping(&m, "a@b\\@c=f@g");
add_mapping(&m, "image@snap_1=image_1");
ImageNameMap::Mapping mapping;
EXPECT_FALSE(m.parse_mapping("bad=@@@", &mapping));
EXPECT_FALSE(m.parse_mapping("bad==stuff", &mapping));
EXPECT_EQ(rbd_loc("", "y", "x"), m.map(rbd_loc("", "x", "y")));
EXPECT_EQ(rbd_loc("", "h", "i"), m.map(rbd_loc("", "a=b", "c")));
EXPECT_EQ(rbd_loc("", "j", "k"), m.map(rbd_loc("", "a", "b=c")));
EXPECT_EQ(rbd_loc("", "d", "e"), m.map(rbd_loc("", "a@b", "c")));
EXPECT_EQ(rbd_loc("", "f", "g"), m.map(rbd_loc("", "a", "b@c")));
EXPECT_EQ(rbd_loc("", "image_1", ""), m.map(rbd_loc("", "image", "snap_1")));
}
TEST(RBDReplay, rbd_loc_str) {
EXPECT_EQ("", rbd_loc("", "", "").str());
EXPECT_EQ("a/", rbd_loc("a", "", "").str());
EXPECT_EQ("b", rbd_loc("", "b", "").str());
EXPECT_EQ("a/b", rbd_loc("a", "b", "").str());
EXPECT_EQ("@c", rbd_loc("", "", "c").str());
EXPECT_EQ("a/@c", rbd_loc("a", "", "c").str());
EXPECT_EQ("b@c", rbd_loc("", "b", "c").str());
EXPECT_EQ("a/b@c", rbd_loc("a", "b", "c").str());
EXPECT_EQ("a\\@x/b\\@y@c\\@z", rbd_loc("a@x", "b@y", "c@z").str());
EXPECT_EQ("a\\/x/b\\/y@c\\/z", rbd_loc("a/x", "b/y", "c/z").str());
EXPECT_EQ("a\\\\x/b\\\\y@c\\\\z", rbd_loc("a\\x", "b\\y", "c\\z").str());
}
TEST(RBDReplay, rbd_loc_parse) {
rbd_loc m("x", "y", "z");
EXPECT_TRUE(m.parse(""));
EXPECT_EQ("", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("a/"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("b"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("a/b"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("@c"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a/@c"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("b@c"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a/b@c"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a\\@x/b\\@y@c\\@z"));
EXPECT_EQ("a@x", m.pool);
EXPECT_EQ("b@y", m.image);
EXPECT_EQ("c@z", m.snap);
EXPECT_TRUE(m.parse("a\\/x/b\\/y@c\\/z"));
EXPECT_EQ("a/x", m.pool);
EXPECT_EQ("b/y", m.image);
EXPECT_EQ("c/z", m.snap);
EXPECT_TRUE(m.parse("a\\\\x/b\\\\y@c\\\\z"));
EXPECT_EQ("a\\x", m.pool);
EXPECT_EQ("b\\y", m.image);
EXPECT_EQ("c\\z", m.snap);
EXPECT_FALSE(m.parse("a@b@c"));
EXPECT_FALSE(m.parse("a/b/c"));
EXPECT_FALSE(m.parse("a@b/c"));
}
| 4,039 | 28.489051 | 87 |
cc
|
null |
ceph-main/src/test/test_rewrite_latency.cc
|
#include <unistd.h>
#include <map>
#include <errno.h>
#include "include/utime.h"
#include "common/Clock.h"
#include "common/errno.h"
using namespace std;
int main(int argc, const char **argv)
{
const char *fn = argv[1];
multimap<utime_t, utime_t> latency;
unsigned max = 10;
int fd = ::open(fn, O_CREAT|O_RDWR, 0644);
if (fd < 1) {
int err = errno;
cerr << "failed to open " << fn << " with " << cpp_strerror(err) << std::endl;
return -1;
}
while (true) {
utime_t now = ceph_clock_now();
int r = ::pwrite(fd, fn, strlen(fn), 0);
ceph_assert(r >= 0);
utime_t lat = ceph_clock_now();
lat -= now;
utime_t oldmin;
if (!latency.empty())
oldmin = latency.begin()->first;
latency.insert(make_pair(lat, now));
utime_t newmin = latency.begin()->first;
while (latency.size() > max)
latency.erase(latency.begin());
if (oldmin == newmin) {
cout << "latency\tat" << std::endl;
for (multimap<utime_t,utime_t>::reverse_iterator p = latency.rbegin();
p != latency.rend();
++p) {
cout << p->first << "\t" << p->second << std::endl;
}
}
}
}
| 1,144 | 22.854167 | 82 |
cc
|
null |
ceph-main/src/test/test_rgw_admin_log.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fstream>
#include <map>
#include <list>
extern "C"{
#include <curl/curl.h>
}
#include "common/ceph_crypto.h"
#include "include/str_list.h"
#include "common/ceph_json.h"
#include "common/code_environment.h"
#include "common/ceph_argparse.h"
#include "common/Finisher.h"
#include "global/global_init.h"
#include "rgw_common.h"
#include "rgw_datalog.h"
#include "rgw_mdlog.h"
#include "rgw_bucket.h"
#include "rgw_rados.h"
#include "include/utime.h"
#include "include/object.h"
#include <gtest/gtest.h>
using namespace std;
#define CURL_VERBOSE 0
#define HTTP_RESPONSE_STR "RespCode"
#define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
#define RGW_ADMIN_RESP_PATH "/tmp/.test_rgw_admin_resp"
#define TEST_BUCKET_NAME "test_bucket"
#define TEST_BUCKET_OBJECT "test_object"
#define TEST_BUCKET_OBJECT_1 "test_object1"
#define TEST_BUCKET_OBJECT_SIZE 1024
static string uid = "ceph";
static string display_name = "CEPH";
extern "C" int ceph_armor(char *dst, const char *dst_end,
const char *src, const char *end);
static void print_usage(char *exec){
cout << "Usage: " << exec << " <Options>\n";
cout << "Options:\n"
"-g <gw-ip> - The ip address of the gateway\n"
"-p <gw-port> - The port number of the gateway\n"
"-c <ceph.conf> - Absolute path of ceph config file\n"
"-rgw-admin <path/to/radosgw-admin> - radosgw-admin absolute path\n";
}
namespace admin_log {
class test_helper {
private:
string host;
string port;
string creds;
string rgw_admin_path;
string conf_path;
CURL *curl_inst;
map<string, string> response;
list<string> extra_hdrs;
string *resp_data;
unsigned resp_code;
public:
test_helper() : resp_data(NULL){
curl_global_init(CURL_GLOBAL_ALL);
}
~test_helper(){
curl_global_cleanup();
}
int send_request(string method, string uri,
size_t (*function)(void *,size_t,size_t,void *) = 0,
void *ud = 0, size_t length = 0);
int extract_input(int argc, char *argv[]);
string& get_response(string hdr){
return response[hdr];
}
void set_extra_header(string hdr){
extra_hdrs.push_back(hdr);
}
void set_response(char *val);
void set_response_data(char *data, size_t len){
if(resp_data) delete resp_data;
resp_data = new string(data, len);
}
string& get_rgw_admin_path() {
return rgw_admin_path;
}
string& get_ceph_conf_path() {
return conf_path;
}
void set_creds(string& c) {
creds = c;
}
const string *get_response_data(){return resp_data;}
unsigned get_resp_code(){return resp_code;}
};
int test_helper::extract_input(int argc, char *argv[]){
#define ERR_CHECK_NEXT_PARAM(o) \
if(((int)loop + 1) >= argc)return -1; \
else o = argv[loop+1];
for(unsigned loop = 1;loop < (unsigned)argc; loop += 2){
if(strcmp(argv[loop], "-g") == 0){
ERR_CHECK_NEXT_PARAM(host);
}else if(strcmp(argv[loop],"-p") == 0){
ERR_CHECK_NEXT_PARAM(port);
}else if(strcmp(argv[loop], "-c") == 0){
ERR_CHECK_NEXT_PARAM(conf_path);
}else if(strcmp(argv[loop], "-rgw-admin") == 0){
ERR_CHECK_NEXT_PARAM(rgw_admin_path);
}else return -1;
}
if(!host.length() || !rgw_admin_path.length())
return -1;
return 0;
}
void test_helper::set_response(char *r){
string sr(r), h, v;
size_t off = sr.find(": ");
if(off != string::npos){
h.assign(sr, 0, off);
v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
}else{
/*Could be the status code*/
if(sr.find("HTTP/") != string::npos){
h.assign(HTTP_RESPONSE_STR);
off = sr.find(" ");
v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
resp_code = atoi((v.substr(0, 3)).c_str());
}
}
response[h] = v;
}
size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
test_helper *h = static_cast<test_helper *>(ud);
h->set_response((char *)ptr);
return size*nmemb;
}
size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
test_helper *h = static_cast<test_helper *>(ud);
h->set_response_data((char *)ptr, size*nmemb);
return size*nmemb;
}
static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
{
int i;
str[0] = '\0';
for (i = 0; i < len; i++) {
sprintf(&str[i*2], "%02x", (int)buf[i]);
}
}
static void calc_hmac_sha1(const char *key, int key_len,
const char *msg, int msg_len, char *dest)
/* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
{
ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
hmac.Update((const unsigned char *)msg, msg_len);
hmac.Final((unsigned char *)dest);
char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
admin_log::buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
}
static int get_s3_auth(const string &method, string creds, const string &date, string res, string& out){
string aid, secret, auth_hdr;
string tmp_res;
size_t off = creds.find(":");
out = "";
if(off != string::npos){
aid.assign(creds, 0, off);
secret.assign(creds, off + 1, string::npos);
/*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
char b64[65]; /* 64 is really enough */
size_t off = res.find("?");
if(off == string::npos)
tmp_res = res;
else
tmp_res.assign(res, 0, off);
auth_hdr.append(method + string("\n\n\n") + date + string("\n") + tmp_res);
admin_log::calc_hmac_sha1(secret.c_str(), secret.length(),
auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
if (ret < 0) {
cout << "ceph_armor failed\n";
return -1;
}
b64[ret] = 0;
out.append(aid + string(":") + b64);
}else return -1;
return 0;
}
void get_date(string& d){
struct timeval tv;
char date[64];
struct tm tm;
char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
(char *)"Wed", (char *)"Thu", (char *)"Fri",
(char *)"Sat"};
char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
(char *)"Apr", (char *)"May", (char *)"Jun",
(char *)"Jul",(char *) "Aug", (char *)"Sep",
(char *)"Oct", (char *)"Nov", (char *)"Dec"};
gettimeofday(&tv, NULL);
gmtime_r(&tv.tv_sec, &tm);
sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
days[tm.tm_wday],
tm.tm_mday, months[tm.tm_mon],
tm.tm_year + 1900,
tm.tm_hour, tm.tm_min, tm.tm_sec);
d = date;
}
int test_helper::send_request(string method, string res,
size_t (*read_function)( void *,size_t,size_t,void *),
void *ud,
size_t length){
string url;
string auth, date;
url.append(string("http://") + host);
if(port.length() > 0)url.append(string(":") + port);
url.append(res);
curl_inst = curl_easy_init();
if(curl_inst){
curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, admin_log::write_header);
curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, admin_log::write_data);
curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
if(read_function){
curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
}
get_date(date);
string http_date;
http_date.append(string("Date: ") + date);
string s3auth;
if (admin_log::get_s3_auth(method, creds, date, res, s3auth) < 0)
return -1;
auth.append(string("Authorization: AWS ") + s3auth);
struct curl_slist *slist = NULL;
slist = curl_slist_append(slist, auth.c_str());
slist = curl_slist_append(slist, http_date.c_str());
for(list<string>::iterator it = extra_hdrs.begin();
it != extra_hdrs.end(); ++it){
slist = curl_slist_append(slist, (*it).c_str());
}
if(read_function)
curl_slist_append(slist, "Expect:");
curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
response.erase(response.begin(), response.end());
extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
CURLcode res = curl_easy_perform(curl_inst);
if(res != CURLE_OK){
cout << "Curl perform failed for " << url << ", res: " <<
curl_easy_strerror(res) << "\n";
return -1;
}
curl_slist_free_all(slist);
}
curl_easy_cleanup(curl_inst);
return 0;
}
};
admin_log::test_helper *g_test;
Finisher *finisher;
int run_rgw_admin(string& cmd, string& resp) {
pid_t pid;
pid = fork();
if (pid == 0) {
/* child */
list<string> l;
get_str_list(cmd, " \t", l);
char *argv[l.size()];
unsigned loop = 1;
argv[0] = (char *)"radosgw-admin";
for (list<string>::iterator it = l.begin();
it != l.end(); ++it) {
argv[loop++] = (char *)(*it).c_str();
}
argv[loop] = NULL;
if (!freopen(RGW_ADMIN_RESP_PATH, "w+", stdout)) {
cout << "Unable to open stdout file" << std::endl;
}
execv((g_test->get_rgw_admin_path()).c_str(), argv);
} else if (pid > 0) {
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status)) {
if(WEXITSTATUS(status) != 0) {
cout << "Child exited with status " << WEXITSTATUS(status) << std::endl;
return -1;
}
}
ifstream in;
struct stat st;
if (stat(RGW_ADMIN_RESP_PATH, &st) < 0) {
cout << "Error stating the admin response file, errno " << errno << std::endl;
return -1;
} else {
char *data = (char *)malloc(st.st_size + 1);
in.open(RGW_ADMIN_RESP_PATH);
in.read(data, st.st_size);
in.close();
data[st.st_size] = 0;
resp = data;
free(data);
unlink(RGW_ADMIN_RESP_PATH);
/* cout << "radosgw-admin " << cmd << ": " << resp << std::endl; */
}
} else
return -1;
return 0;
}
int get_creds(string& json, string& creds) {
JSONParser parser;
if(!parser.parse(json.c_str(), json.length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
RGWUserInfo info;
decode_json_obj(info, &parser);
creds = "";
for(map<string, RGWAccessKey>::iterator it = info.access_keys.begin();
it != info.access_keys.end(); ++it) {
RGWAccessKey _k = it->second;
/*cout << "accesskeys [ " << it->first << " ] = " <<
"{ " << _k.id << ", " << _k.key << ", " << _k.subuser << "}" << std::endl;*/
creds.append(it->first + string(":") + _k.key);
break;
}
return 0;
}
int user_create(string& uid, string& display_name, bool set_creds = true) {
stringstream ss;
string creds;
ss << "-c " << g_test->get_ceph_conf_path() << " user create --uid=" << uid
<< " --display-name=" << display_name;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
get_creds(out, creds);
if(set_creds)
g_test->set_creds(creds);
return 0;
}
int user_info(string& uid, string& display_name, RGWUserInfo& uinfo) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " user info --uid=" << uid
<< " --display-name=" << display_name;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error reading user information" << std::endl;
return -1;
}
JSONParser parser;
if(!parser.parse(out.c_str(), out.length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
decode_json_obj(uinfo, &parser);
return 0;
}
int user_rm(string& uid, string& display_name) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() <<
" metadata rm --metadata-key=user:" << uid;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error removing user" << std::endl;
return -1;
}
return 0;
}
int caps_add(const char * name, const char *perm) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " caps add --caps=" <<
name << "=" << perm << " --uid=" << uid;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
return 0;
}
int caps_rm(const char * name, const char *perm) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " caps rm --caps=" <<
name << "=" << perm << " --uid=" << uid;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
return 0;
}
static int create_bucket(void){
g_test->send_request(string("PUT"), string("/" TEST_BUCKET_NAME));
if(g_test->get_resp_code() != 200U){
cout << "Error creating bucket, http code " << g_test->get_resp_code();
return -1;
}
return 0;
}
static int delete_bucket(void){
g_test->send_request(string("DELETE"), string("/" TEST_BUCKET_NAME));
if(g_test->get_resp_code() != 204U){
cout << "Error deleting bucket, http code " << g_test->get_resp_code();
return -1;
}
return 0;
}
size_t read_dummy_post(void *ptr, size_t s, size_t n, void *ud) {
int dummy = 0;
memcpy(ptr, &dummy, sizeof(dummy));
return sizeof(dummy);
}
size_t read_bucket_object(void *ptr, size_t s, size_t n, void *ud) {
memcpy(ptr, ud, TEST_BUCKET_OBJECT_SIZE);
return TEST_BUCKET_OBJECT_SIZE;
}
static int put_bucket_obj(const char *obj_name, char *data, unsigned len) {
string req = "/" TEST_BUCKET_NAME"/";
req.append(obj_name);
g_test->send_request(string("PUT"), req,
read_bucket_object, (void *)data, (size_t)len);
if (g_test->get_resp_code() != 200U) {
cout << "Errror sending object to the bucket, http_code " << g_test->get_resp_code();
return -1;
}
return 0;
}
static int read_bucket_obj(const char *obj_name) {
string req = "/" TEST_BUCKET_NAME"/";
req.append(obj_name);
g_test->send_request(string("GET"), req);
if (g_test->get_resp_code() != 200U) {
cout << "Errror sending object to the bucket, http_code " << g_test->get_resp_code();
return -1;
}
return 0;
}
static int delete_obj(const char *obj_name) {
string req = "/" TEST_BUCKET_NAME"/";
req.append(obj_name);
g_test->send_request(string("DELETE"), req);
if (g_test->get_resp_code() != 204U) {
cout << "Errror deleting object from bucket, http_code " << g_test->get_resp_code();
return -1;
}
return 0;
}
int get_formatted_time(string& ret) {
struct tm *tm = NULL;
char str_time[200];
const char *format = "%Y-%m-%d%%20%H:%M:%S";
time_t t;
t = time(NULL);
tm = gmtime(&t);
if(!tm) {
cerr << "Error returned by gmtime\n";
return -1;
}
if (strftime(str_time, sizeof(str_time), format, tm) == 0) {
cerr << "Error returned by strftime\n";
return -1;
}
ret = str_time;
return 0;
}
int parse_json_resp(JSONParser &parser) {
string *resp;
resp = (string *)g_test->get_response_data();
if(!resp)
return -1;
if(!parser.parse(resp->c_str(), resp->length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
return 0;
}
struct cls_log_entry_json {
string section;
string name;
utime_t timestamp;
RGWMetadataLogData log_data;
};
static int decode_json(JSONObj *obj, RGWMetadataLogData &data) {
JSONObj *jo;
jo = obj->find_obj("read_version");
if (!jo)
return -1;
data.read_version.decode_json(obj);
data.write_version.decode_json(obj);
jo = obj->find_obj("status");
if (!jo)
return -1;
JSONDecoder::decode_json("status", data, jo);
return 0;
}
static int decode_json(JSONObj *obj, cls_log_entry_json& ret) {
JSONDecoder::decode_json("section", ret.section, obj);
JSONDecoder::decode_json("name", ret.name, obj);
JSONObj *jo = obj->find_obj("data");
if(!jo)
return 0;
return decode_json(jo, ret.log_data);
}
static int get_log_list(list<cls_log_entry_json> &entries) {
JSONParser parser;
if (parse_json_resp(parser) != 0)
return -1;
if (!parser.is_array())
return -1;
vector<string> l;
l = parser.get_array_elements();
int loop = 0;
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it, loop++) {
JSONParser jp;
cls_log_entry_json entry;
if(!jp.parse((*it).c_str(), (*it).length())) {
cerr << "Error parsing log json object" << std::endl;
return -1;
}
EXPECT_EQ(decode_json((JSONObj *)&jp, entry), 0);
entries.push_back(entry);
}
return 0;
}
struct cls_bilog_entry {
string op_id;
string op_tag;
string op;
string object;
string status;
unsigned index_ver;
};
static int decode_json(JSONObj *obj, cls_bilog_entry& ret) {
JSONDecoder::decode_json("op_id", ret.op_id, obj);
JSONDecoder::decode_json("op_tag", ret.op_tag, obj);
JSONDecoder::decode_json("op", ret.op, obj);
JSONDecoder::decode_json("object", ret.object, obj);
JSONDecoder::decode_json("state", ret.status, obj);
JSONDecoder::decode_json("index_ver", ret.index_ver, obj);
return 0;
}
static int get_bilog_list(list<cls_bilog_entry> &entries) {
JSONParser parser;
if (parse_json_resp(parser) != 0)
return -1;
if (!parser.is_array())
return -1;
vector<string> l;
l = parser.get_array_elements();
int loop = 0;
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it, loop++) {
JSONParser jp;
cls_bilog_entry entry;
if(!jp.parse((*it).c_str(), (*it).length())) {
cerr << "Error parsing log json object" << std::endl;
return -1;
}
EXPECT_EQ(decode_json((JSONObj *)&jp, entry), 0);
entries.push_back(entry);
}
return 0;
}
static int decode_json(JSONObj *obj, rgw_data_change& ret) {
string entity;
JSONDecoder::decode_json("entity_type", entity, obj);
if (entity.compare("bucket") == 0)
ret.entity_type = ENTITY_TYPE_BUCKET;
JSONDecoder::decode_json("key", ret.key, obj);
return 0;
}
static int get_datalog_list(list<rgw_data_change> &entries) {
JSONParser parser;
if (parse_json_resp(parser) != 0)
return -1;
if (!parser.is_array())
return -1;
vector<string> l;
l = parser.get_array_elements();
int loop = 0;
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it, loop++) {
JSONParser jp;
rgw_data_change entry;
if(!jp.parse((*it).c_str(), (*it).length())) {
cerr << "Error parsing log json object" << std::endl;
return -1;
}
EXPECT_EQ(decode_json((JSONObj *)&jp, entry), 0);
entries.push_back(entry);
}
return 0;
}
unsigned get_mdlog_shard_id(string& key, int max_shards) {
string section = "user";
uint32_t val = ceph_str_hash_linux(key.c_str(), key.size());
val ^= ceph_str_hash_linux(section.c_str(), section.size());
return (unsigned)(val % max_shards);
}
unsigned get_datalog_shard_id(const char *bucket_name, int max_shards) {
uint32_t r = ceph_str_hash_linux(bucket_name, strlen(bucket_name)) % max_shards;
return (int)r;
}
TEST(TestRGWAdmin, datalog_list) {
string start_time,
end_time;
const char *cname = "datalog",
*perm = "*";
string rest_req;
unsigned shard_id = get_datalog_shard_id(TEST_BUCKET_NAME, g_ceph_context->_conf->rgw_data_log_num_shards);
stringstream ss;
list<rgw_data_change> entries;
ASSERT_EQ(get_formatted_time(start_time), 0);
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data";
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
JSONParser parser;
int num_objects;
EXPECT_EQ (parse_json_resp(parser), 0);
JSONDecoder::decode_json("num_objects", num_objects, (JSONObj *)&parser);
ASSERT_EQ(num_objects,g_ceph_context->_conf->rgw_data_log_num_shards);
sleep(1);
ASSERT_EQ(0, create_bucket());
char *bucket_obj = (char *)calloc(1, TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
sleep(1);
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_EQ(1U, entries.size());
if (entries.size() == 1) {
rgw_data_change entry = *(entries.begin());
EXPECT_EQ(entry.entity_type, ENTITY_TYPE_BUCKET);
EXPECT_EQ(entry.key.compare(TEST_BUCKET_NAME), 0);
}
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
sleep(1);
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_EQ(1U, entries.size());
if (entries.size() == 1) {
list<rgw_data_change>::iterator it = (entries.begin());
EXPECT_EQ((*it).entity_type, ENTITY_TYPE_BUCKET);
EXPECT_EQ((*it).key.compare(TEST_BUCKET_NAME), 0);
}
sleep(1);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
free(bucket_obj);
sleep(20);
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_EQ(2U, entries.size());
if (entries.size() == 2) {
list<rgw_data_change>::iterator it = (entries.begin());
EXPECT_EQ((*it).entity_type, ENTITY_TYPE_BUCKET);
EXPECT_EQ((*it).key.compare(TEST_BUCKET_NAME), 0);
++it;
EXPECT_EQ((*it).entity_type, ENTITY_TYPE_BUCKET);
EXPECT_EQ((*it).key.compare(TEST_BUCKET_NAME), 0);
}
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&max-entries=1";
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_EQ(1U, entries.size());
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_EQ(1U, entries.size());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "read";
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
ASSERT_EQ(0, delete_bucket());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, datalog_lock_unlock) {
const char *cname = "datalog",
*perm = "*";
string rest_req;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data&lock&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&lock&id=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&lock&length=3&id=1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&lock&length=3&id=1&locker-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&unlock&id=1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&unlock&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&unlock&locker-id=ceph&id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
utime_t sleep_time(3, 0);
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(500U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph1&zone-id=2";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(500U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
sleep_time.sleep();
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "read";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
rest_req = "/admin/log?type=data&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, datalog_trim) {
string start_time,
end_time;
const char *cname = "datalog",
*perm = "*";
string rest_req;
unsigned shard_id = get_datalog_shard_id(TEST_BUCKET_NAME, g_ceph_context->_conf->rgw_data_log_num_shards);
stringstream ss;
list<rgw_data_change> entries;
ASSERT_EQ(get_formatted_time(start_time), 0);
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data";
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
ss.str("");
ss << "/admin/log?type=data&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
ASSERT_EQ(0, create_bucket());
char *bucket_obj = (char *)calloc(1, TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
sleep(1);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
sleep(20);
free(bucket_obj);
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_TRUE(!entries.empty());
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_datalog_list(entries);
EXPECT_TRUE(entries.empty());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "";
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, mdlog_list) {
string start_time,
end_time,
start_time_2;
const char *cname = "mdlog",
*perm = "*";
string rest_req;
unsigned shard_id = get_mdlog_shard_id(uid, g_ceph_context->_conf->rgw_md_log_max_shards);
stringstream ss;
sleep(2);
ASSERT_EQ(get_formatted_time(start_time), 0);
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=metadata";
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
JSONParser parser;
int num_objects;
EXPECT_EQ (parse_json_resp(parser), 0);
JSONDecoder::decode_json("num_objects", num_objects, (JSONObj *)&parser);
ASSERT_EQ(num_objects,g_ceph_context->_conf->rgw_md_log_max_shards);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
list<cls_log_entry_json> entries;
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 4U);
if(entries.size() == 4) {
list<cls_log_entry_json>::iterator it = entries.begin();
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_WRITE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_COMPLETE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_WRITE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_COMPLETE);
}
sleep(1); /*To get a modified time*/
ASSERT_EQ(get_formatted_time(start_time_2), 0);
ASSERT_EQ(0, caps_rm(cname, perm));
perm="read";
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time_2;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 4U);
if(entries.size() == 4) {
list<cls_log_entry_json>::iterator it = entries.begin();
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_WRITE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_COMPLETE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_WRITE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_COMPLETE);
}
sleep(1);
ASSERT_EQ(get_formatted_time(start_time_2), 0);
ASSERT_EQ(0, user_rm(uid, display_name));
ASSERT_EQ(0, user_create(uid, display_name));
perm = "*";
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time_2;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 6U);
if(entries.size() == 6) {
list<cls_log_entry_json>::iterator it = entries.begin();
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_REMOVE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_WRITE);
++it;
EXPECT_TRUE(it->section.compare("user") == 0);
EXPECT_TRUE(it->name.compare(uid) == 0);
EXPECT_TRUE(it->log_data.status == MDLOG_STATUS_COMPLETE);
}
sleep(1);
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 14U);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time
<< "&max-entries=" << 1;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 1U);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time
<< "&max-entries=" << 6;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 6U);
ASSERT_EQ(0, caps_rm(cname, perm));
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(403U, g_test->get_resp_code());
/*cleanup*/
ASSERT_EQ(0, caps_add(cname, perm));
sleep(1);
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time
<< "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, mdlog_trim) {
string start_time,
end_time;
const char *cname = "mdlog",
*perm = "*";
string rest_req;
list<cls_log_entry_json> entries;
unsigned shard_id = get_mdlog_shard_id(uid, g_ceph_context->_conf->rgw_md_log_max_shards);
ostringstream ss;
sleep(1);
ASSERT_EQ(get_formatted_time(start_time), 0);
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 4U);
sleep(1);
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time << "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
EXPECT_EQ(get_log_list(entries), 0);
EXPECT_EQ(entries.size(), 0U);
ASSERT_EQ(0, caps_rm(cname, perm));
perm="write";
ASSERT_EQ(0, caps_add(cname, perm));
ASSERT_EQ(get_formatted_time(end_time), 0);
ss.str("");
ss << "/admin/log?type=metadata&id=" << shard_id << "&start-time=" << start_time << "&end-time=" << end_time;
rest_req = ss.str();
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, mdlog_lock_unlock) {
const char *cname = "mdlog",
*perm = "*";
string rest_req;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=metadata&lock&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&lock&id=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&lock&length=3&id=1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&lock&id=3&locker-id=ceph&length=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&unlock&id=1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&unlock&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&unlock&locker-id=ceph&id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
utime_t sleep_time(3, 0);
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(500U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=2";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(500U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
sleep_time.sleep();
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph1&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "read";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&locker-id=ceph&zone-id=1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, bilog_list) {
const char *cname = "bilog",
*perm = "*";
string rest_req;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
ASSERT_EQ(0, create_bucket());
char *bucket_obj = (char *)calloc(1, TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
free(bucket_obj);
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
list<cls_bilog_entry> entries;
get_bilog_list(entries);
EXPECT_EQ(2U, entries.size());
if (entries.size() == 2) {
list<cls_bilog_entry>::iterator it = entries.begin();
EXPECT_EQ(it->op.compare("write"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT), 0);
EXPECT_EQ(it->status.compare("pending"), 0);
EXPECT_EQ(it->index_ver, 1U);
++it;
EXPECT_EQ(it->op.compare("write"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT), 0);
EXPECT_EQ(it->status.compare("complete"), 0);
EXPECT_EQ(it->index_ver, 2U);
}
EXPECT_EQ(read_bucket_obj(TEST_BUCKET_OBJECT), 0);
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(2U, entries.size());
bucket_obj = (char *)calloc(1, TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT_1, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
free(bucket_obj);
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(4U, entries.size());
if (entries.size() == 4) {
list<cls_bilog_entry>::iterator it = entries.begin();
++it; ++it;
EXPECT_EQ(it->op.compare("write"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT_1), 0);
EXPECT_EQ(it->status.compare("pending"), 0);
EXPECT_EQ(it->index_ver, 3U);
++it;
EXPECT_EQ(it->op.compare("write"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT_1), 0);
EXPECT_EQ(it->status.compare("complete"), 0);
EXPECT_EQ(it->index_ver, 4U);
}
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(6U, entries.size());
string marker;
if (entries.size() == 6) {
list<cls_bilog_entry>::iterator it = entries.begin();
++it; ++it; ++it; ++it;
marker = it->op_id;
EXPECT_EQ(it->op.compare("del"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT), 0);
EXPECT_EQ(it->status.compare("pending"), 0);
EXPECT_EQ(it->index_ver, 5U);
++it;
EXPECT_EQ(it->op.compare("del"), 0);
EXPECT_EQ(it->object.compare(TEST_BUCKET_OBJECT), 0);
EXPECT_EQ(it->status.compare("complete"), 0);
EXPECT_EQ(it->index_ver, 6U);
}
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
rest_req.append("&marker=");
rest_req.append(marker);
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(2U, entries.size());
if (entries.size() == 2U) {
list<cls_bilog_entry>::iterator it = entries.begin();
EXPECT_EQ(it->index_ver, 5U);
++it;
EXPECT_EQ(it->index_ver, 6U);
EXPECT_EQ(it->op.compare("del"), 0);
}
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
rest_req.append("&marker=");
rest_req.append(marker);
rest_req.append("&max-entries=1");
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(1U, entries.size());
EXPECT_EQ((entries.begin())->index_ver, 5U);
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "read";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT_1));
ASSERT_EQ(0, delete_bucket());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, bilog_trim) {
const char *cname = "bilog",
*perm = "*";
string rest_req, start_marker, end_marker;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, caps_add(cname, perm));
ASSERT_EQ(0, create_bucket());
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
char *bucket_obj = (char *)calloc(1, TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
free(bucket_obj);
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
list<cls_bilog_entry> entries;
get_bilog_list(entries);
EXPECT_EQ(2U, entries.size());
list<cls_bilog_entry>::iterator it = entries.begin();
start_marker = it->op_id;
++it;
end_marker = it->op_id;
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
rest_req.append("&start-marker=");
rest_req.append(start_marker);
rest_req.append("&end-marker=");
rest_req.append(end_marker);
g_test->send_request(string("DELETE"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/log?type=bucket-index&bucket=" TEST_BUCKET_NAME;
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(200U, g_test->get_resp_code());
entries.clear();
get_bilog_list(entries);
EXPECT_EQ(0U, entries.size());
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
ASSERT_EQ(0, delete_bucket());
ASSERT_EQ(0, user_rm(uid, display_name));
}
int main(int argc, char *argv[]){
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_test = new admin_log::test_helper();
finisher = new Finisher(g_ceph_context);
#ifdef GTEST
::testing::InitGoogleTest(&argc, argv);
#endif
finisher->start();
if(g_test->extract_input(argc, argv) < 0){
print_usage(argv[0]);
return -1;
}
#ifdef GTEST
int r = RUN_ALL_TESTS();
if (r >= 0) {
cout << "There are no failures in the test case\n";
} else {
cout << "There are some failures\n";
}
#endif
finisher->stop();
return 0;
}
| 53,791 | 32.810182 | 111 |
cc
|
null |
ceph-main/src/test/test_rgw_admin_meta.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fstream>
#include <map>
#include <list>
extern "C"{
#include <curl/curl.h>
}
#include "common/ceph_crypto.h"
#include "include/str_list.h"
#include "common/ceph_json.h"
#include "common/code_environment.h"
#include "common/ceph_argparse.h"
#include "common/Finisher.h"
#include "global/global_init.h"
#include "rgw_common.h"
#include "rgw_rados.h"
#include <gtest/gtest.h>
using namespace std;
#define CURL_VERBOSE 0
#define HTTP_RESPONSE_STR "RespCode"
#define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
#define RGW_ADMIN_RESP_PATH "/tmp/.test_rgw_admin_resp"
#define CEPH_UID "ceph"
static string uid = CEPH_UID;
static string display_name = "CEPH";
static string meta_caps = "metadata";
extern "C" int ceph_armor(char *dst, const char *dst_end,
const char *src, const char *end);
static void print_usage(char *exec){
cout << "Usage: " << exec << " <Options>\n";
cout << "Options:\n"
"-g <gw-ip> - The ip address of the gateway\n"
"-p <gw-port> - The port number of the gateway\n"
"-c <ceph.conf> - Absolute path of ceph config file\n"
"-rgw-admin <path/to/radosgw-admin> - radosgw-admin absolute path\n";
}
namespace admin_meta {
class test_helper {
private:
string host;
string port;
string creds;
string rgw_admin_path;
string conf_path;
CURL *curl_inst;
map<string, string> response;
list<string> extra_hdrs;
string *resp_data;
unsigned resp_code;
public:
test_helper() : curl_inst(0), resp_data(NULL), resp_code(0) {
curl_global_init(CURL_GLOBAL_ALL);
}
~test_helper(){
curl_global_cleanup();
}
int send_request(string method, string uri,
size_t (*function)(void *,size_t,size_t,void *) = 0,
void *ud = 0, size_t length = 0);
int extract_input(int argc, char *argv[]);
string& get_response(string hdr){
return response[hdr];
}
void set_extra_header(string hdr){
extra_hdrs.push_back(hdr);
}
void set_response(char *val);
void set_response_data(char *data, size_t len){
if(resp_data) delete resp_data;
resp_data = new string(data, len);
}
string& get_rgw_admin_path() {
return rgw_admin_path;
}
string& get_ceph_conf_path() {
return conf_path;
}
void set_creds(string& c) {
creds = c;
}
const string *get_response_data(){return resp_data;}
unsigned get_resp_code(){return resp_code;}
};
int test_helper::extract_input(int argc, char *argv[]){
#define ERR_CHECK_NEXT_PARAM(o) \
if(((int)loop + 1) >= argc)return -1; \
else o = argv[loop+1];
for(unsigned loop = 1;loop < (unsigned)argc; loop += 2){
if(strcmp(argv[loop], "-g") == 0){
ERR_CHECK_NEXT_PARAM(host);
}else if(strcmp(argv[loop],"-p") == 0){
ERR_CHECK_NEXT_PARAM(port);
}else if(strcmp(argv[loop], "-c") == 0){
ERR_CHECK_NEXT_PARAM(conf_path);
}else if(strcmp(argv[loop], "-rgw-admin") == 0){
ERR_CHECK_NEXT_PARAM(rgw_admin_path);
}else return -1;
}
if(host.empty() || rgw_admin_path.empty())
return -1;
return 0;
}
void test_helper::set_response(char *r){
string sr(r), h, v;
size_t off = sr.find(": ");
if(off != string::npos){
h.assign(sr, 0, off);
v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
}else{
/*Could be the status code*/
if(sr.find("HTTP/") != string::npos){
h.assign(HTTP_RESPONSE_STR);
off = sr.find(" ");
v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
resp_code = atoi((v.substr(0, 3)).c_str());
}
}
response[h] = v;
}
size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
test_helper *h = static_cast<test_helper *>(ud);
h->set_response((char *)ptr);
return size*nmemb;
}
size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
test_helper *h = static_cast<test_helper *>(ud);
h->set_response_data((char *)ptr, size*nmemb);
return size*nmemb;
}
static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
{
int i;
str[0] = '\0';
for (i = 0; i < len; i++) {
sprintf(&str[i*2], "%02x", (int)buf[i]);
}
}
static void calc_hmac_sha1(const char *key, int key_len,
const char *msg, int msg_len, char *dest)
/* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
{
ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
hmac.Update((const unsigned char *)msg, msg_len);
hmac.Final((unsigned char *)dest);
char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
admin_meta::buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
}
static int get_s3_auth(const string &method, string creds, const string &date, string res, string& out){
string aid, secret, auth_hdr;
string tmp_res;
size_t off = creds.find(":");
out = "";
if(off != string::npos){
aid.assign(creds, 0, off);
secret.assign(creds, off + 1, string::npos);
/*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
char b64[65]; /* 64 is really enough */
size_t off = res.find("?");
if(off == string::npos)
tmp_res = res;
else
tmp_res.assign(res, 0, off);
auth_hdr.append(method + string("\n\n\n") + date + string("\n") + tmp_res);
admin_meta::calc_hmac_sha1(secret.c_str(), secret.length(),
auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
if (ret < 0) {
cout << "ceph_armor failed\n";
return -1;
}
b64[ret] = 0;
out.append(aid + string(":") + b64);
}else return -1;
return 0;
}
void get_date(string& d){
struct timeval tv;
char date[64];
struct tm tm;
char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
(char *)"Wed", (char *)"Thu", (char *)"Fri",
(char *)"Sat"};
char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
(char *)"Apr", (char *)"May", (char *)"Jun",
(char *)"Jul",(char *) "Aug", (char *)"Sep",
(char *)"Oct", (char *)"Nov", (char *)"Dec"};
gettimeofday(&tv, NULL);
gmtime_r(&tv.tv_sec, &tm);
sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
days[tm.tm_wday],
tm.tm_mday, months[tm.tm_mon],
tm.tm_year + 1900,
tm.tm_hour, tm.tm_min, 0 /*tm.tm_sec*/);
d = date;
}
int test_helper::send_request(string method, string res,
size_t (*read_function)( void *,size_t,size_t,void *),
void *ud,
size_t length){
string url;
string auth, date;
url.append(string("http://") + host);
if(port.length() > 0)url.append(string(":") + port);
url.append(res);
curl_inst = curl_easy_init();
if(curl_inst){
curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, admin_meta::write_header);
curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, admin_meta::write_data);
curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
if(read_function){
curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
}
get_date(date);
string http_date;
http_date.append(string("Date: ") + date);
string s3auth;
if (admin_meta::get_s3_auth(method, creds, date, res, s3auth) < 0)
return -1;
auth.append(string("Authorization: AWS ") + s3auth);
struct curl_slist *slist = NULL;
slist = curl_slist_append(slist, auth.c_str());
slist = curl_slist_append(slist, http_date.c_str());
for(list<string>::iterator it = extra_hdrs.begin();
it != extra_hdrs.end(); ++it){
slist = curl_slist_append(slist, (*it).c_str());
}
if(read_function)
curl_slist_append(slist, "Expect:");
curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
response.erase(response.begin(), response.end());
extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
CURLcode res = curl_easy_perform(curl_inst);
if(res != CURLE_OK){
cout << "Curl perform failed for " << url << ", res: " <<
curl_easy_strerror(res) << "\n";
return -1;
}
curl_slist_free_all(slist);
}
curl_easy_cleanup(curl_inst);
return 0;
}
};
admin_meta::test_helper *g_test;
Finisher *finisher;
int run_rgw_admin(string& cmd, string& resp) {
pid_t pid;
pid = fork();
if (pid == 0) {
/* child */
list<string> l;
get_str_list(cmd, " \t", l);
char *argv[l.size()];
unsigned loop = 1;
argv[0] = (char *)"radosgw-admin";
for (list<string>::iterator it = l.begin();
it != l.end(); ++it) {
argv[loop++] = (char *)(*it).c_str();
}
argv[loop] = NULL;
if (!freopen(RGW_ADMIN_RESP_PATH, "w+", stdout)) {
cout << "Unable to open stdout file" << std::endl;
}
execv((g_test->get_rgw_admin_path()).c_str(), argv);
} else if (pid > 0) {
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status)) {
if(WEXITSTATUS(status) != 0) {
cout << "Child exited with status " << WEXITSTATUS(status) << std::endl;
return -1;
}
}
ifstream in;
struct stat st;
if (stat(RGW_ADMIN_RESP_PATH, &st) < 0) {
cout << "Error stating the admin response file, errno " << errno << std::endl;
return -1;
} else {
char *data = (char *)malloc(st.st_size + 1);
in.open(RGW_ADMIN_RESP_PATH);
in.read(data, st.st_size);
in.close();
data[st.st_size] = 0;
resp = data;
free(data);
unlink(RGW_ADMIN_RESP_PATH);
/* cout << "radosgw-admin " << cmd << ": " << resp << std::endl;*/
}
} else
return -1;
return 0;
}
int get_creds(string& json, string& creds) {
JSONParser parser;
if(!parser.parse(json.c_str(), json.length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
RGWUserInfo info;
decode_json_obj(info, &parser);
creds = "";
for(map<string, RGWAccessKey>::iterator it = info.access_keys.begin();
it != info.access_keys.end(); ++it) {
RGWAccessKey _k = it->second;
/*cout << "accesskeys [ " << it->first << " ] = " <<
"{ " << _k.id << ", " << _k.key << ", " << _k.subuser << "}" << std::endl;*/
creds.append(it->first + string(":") + _k.key);
break;
}
return 0;
}
int user_create(string& uid, string& display_name, bool set_creds = true) {
stringstream ss;
string creds;
ss << "-c " << g_test->get_ceph_conf_path() << " user create --uid=" << uid
<< " --display-name=" << display_name;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
get_creds(out, creds);
if(set_creds)
g_test->set_creds(creds);
return 0;
}
int user_info(string& uid, string& display_name, RGWUserInfo& uinfo) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " user info --uid=" << uid
<< " --display-name=" << display_name;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error reading user information" << std::endl;
return -1;
}
JSONParser parser;
if(!parser.parse(out.c_str(), out.length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
decode_json_obj(uinfo, &parser);
return 0;
}
int user_rm(string& uid, string& display_name) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " user rm --uid=" << uid
<< " --display-name=" << display_name;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error removing user" << std::endl;
return -1;
}
return 0;
}
int meta_caps_add(const char *perm) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " caps add --caps=" <<
meta_caps << "=" << perm << " --uid=" << uid;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
return 0;
}
int meta_caps_rm(const char *perm) {
stringstream ss;
ss << "-c " << g_test->get_ceph_conf_path() << " caps rm --caps=" <<
meta_caps << "=" << perm << " --uid=" << uid;
string out;
string cmd = ss.str();
if(run_rgw_admin(cmd, out) != 0) {
cout << "Error creating user" << std::endl;
return -1;
}
return 0;
}
int compare_access_keys(RGWAccessKey& k1, RGWAccessKey& k2) {
if (k1.id.compare(k2.id) != 0)
return -1;
if (k1.key.compare(k2.key) != 0)
return -1;
if (k1.subuser.compare(k2.subuser) != 0)
return -1;
return 0;
}
int compare_user_info(RGWUserInfo& i1, RGWUserInfo& i2) {
int rv;
if ((rv = i1.user_id.compare(i2.user_id)) != 0)
return rv;
if ((rv = i1.display_name.compare(i2.display_name)) != 0)
return rv;
if ((rv = i1.user_email.compare(i2.user_email)) != 0)
return rv;
if (i1.access_keys.size() != i2.access_keys.size())
return -1;
for (map<string, RGWAccessKey>::iterator it = i1.access_keys.begin();
it != i1.access_keys.end(); ++it) {
RGWAccessKey k1, k2;
k1 = it->second;
if (i2.access_keys.count(it->first) == 0)
return -1;
k2 = i2.access_keys[it->first];
if (compare_access_keys(k1, k2) != 0)
return -1;
}
if (i1.swift_keys.size() != i2.swift_keys.size())
return -1;
for (map<string, RGWAccessKey>::iterator it = i1.swift_keys.begin();
it != i1.swift_keys.end(); ++it) {
RGWAccessKey k1, k2;
k1 = it->second;
if (i2.swift_keys.count(it->first) == 0)
return -1;
k2 = i2.swift_keys[it->first];
if (compare_access_keys(k1, k2) != 0)
return -1;
}
if (i1.subusers.size() != i2.subusers.size())
return -1;
for (map<string, RGWSubUser>::iterator it = i1.subusers.begin();
it != i1.subusers.end(); ++it) {
RGWSubUser k1, k2;
k1 = it->second;
if (!i2.subusers.count(it->first))
return -1;
k2 = i2.subusers[it->first];
if (k1.name.compare(k2.name) != 0)
return -1;
if (k1.perm_mask != k2.perm_mask)
return -1;
}
if (i1.suspended != i2.suspended)
return -1;
if (i1.max_buckets != i2.max_buckets)
return -1;
uint32_t p1, p2;
p1 = p2 = RGW_CAP_ALL;
if (i1.caps.check_cap(meta_caps, p1) != 0)
return -1;
if (i2.caps.check_cap(meta_caps, p2) != 0)
return -1;
return 0;
}
size_t read_dummy_post(void *ptr, size_t s, size_t n, void *ud) {
int dummy = 0;
memcpy(ptr, &dummy, sizeof(dummy));
return sizeof(dummy);
}
int parse_json_resp(JSONParser &parser) {
string *resp;
resp = (string *)g_test->get_response_data();
if(!resp)
return -1;
if(!parser.parse(resp->c_str(), resp->length())) {
cout << "Error parsing create user response" << std::endl;
return -1;
}
return 0;
}
size_t meta_read_json(void *ptr, size_t s, size_t n, void *ud){
stringstream *ss = (stringstream *)ud;
size_t len = ss->str().length();
if(s*n < len){
cout << "Cannot copy json data, as len is not enough\n";
return 0;
}
memcpy(ptr, (void *)ss->str().c_str(), len);
return len;
}
TEST(TestRGWAdmin, meta_list){
JSONParser parser;
bool found = false;
const char *perm = "*";
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, meta_caps_add(perm));
/*Check the sections*/
g_test->send_request(string("GET"), string("/admin/metadata/"));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser) == 0);
EXPECT_TRUE(parser.is_array());
vector<string> l;
l = parser.get_array_elements();
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it) {
if((*it).compare("\"user\"") == 0) {
found = true;
break;
}
}
EXPECT_TRUE(found);
/*Check with a wrong section*/
g_test->send_request(string("GET"), string("/admin/metadata/users"));
EXPECT_EQ(404U, g_test->get_resp_code());
/*Check the list of keys*/
g_test->send_request(string("GET"), string("/admin/metadata/user"));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser) == 0);
EXPECT_TRUE(parser.is_array());
l = parser.get_array_elements();
EXPECT_EQ(1U, l.size());
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it) {
if((*it).compare(string("\"") + uid + string("\"")) == 0) {
found = true;
break;
}
}
EXPECT_TRUE(found);
/*Check with second user*/
string uid2 = "ceph1", display_name2 = "CEPH1";
ASSERT_EQ(0, user_create(uid2, display_name2, false));
/*Check the list of keys*/
g_test->send_request(string("GET"), string("/admin/metadata/user"));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser) == 0);
EXPECT_TRUE(parser.is_array());
l = parser.get_array_elements();
EXPECT_EQ(2U, l.size());
bool found2 = false;
for(vector<string>::iterator it = l.begin();
it != l.end(); ++it) {
if((*it).compare(string("\"") + uid + string("\"")) == 0) {
found = true;
}
if((*it).compare(string("\"") + uid2 + string("\"")) == 0) {
found2 = true;
}
}
EXPECT_TRUE(found && found2);
ASSERT_EQ(0, user_rm(uid2, display_name2));
/*Remove the metadata caps*/
int rv = meta_caps_rm(perm);
EXPECT_EQ(0, rv);
if(rv == 0) {
g_test->send_request(string("GET"), string("/admin/metadata/"));
EXPECT_EQ(403U, g_test->get_resp_code());
g_test->send_request(string("GET"), string("/admin/metadata/user"));
EXPECT_EQ(403U, g_test->get_resp_code());
}
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, meta_get){
JSONParser parser;
const char *perm = "*";
RGWUserInfo info;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, meta_caps_add(perm));
ASSERT_EQ(0, user_info(uid, display_name, info));
g_test->send_request(string("GET"), string("/admin/metadata/user?key=test"));
EXPECT_EQ(404U, g_test->get_resp_code());
g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser) == 0);
RGWObjVersionTracker objv_tracker;
string metadata_key;
obj_version *objv = &objv_tracker.read_version;
JSONDecoder::decode_json("key", metadata_key, &parser);
JSONDecoder::decode_json("ver", *objv, &parser);
JSONObj *jo = parser.find_obj("data");
ASSERT_TRUE(jo);
string exp_meta_key = "user:";
exp_meta_key.append(uid);
EXPECT_TRUE(metadata_key.compare(exp_meta_key) == 0);
RGWUserInfo obt_info;
decode_json_obj(obt_info, jo);
EXPECT_TRUE(compare_user_info(info, obt_info) == 0);
/*Make a modification and check if its reflected*/
ASSERT_EQ(0, meta_caps_rm(perm));
perm = "read";
ASSERT_EQ(0, meta_caps_add(perm));
JSONParser parser1;
g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser1) == 0);
RGWObjVersionTracker objv_tracker1;
obj_version *objv1 = &objv_tracker1.read_version;
JSONDecoder::decode_json("key", metadata_key, &parser1);
JSONDecoder::decode_json("ver", *objv1, &parser1);
jo = parser1.find_obj("data");
ASSERT_TRUE(jo);
decode_json_obj(obt_info, jo);
uint32_t p1, p2;
p1 = RGW_CAP_ALL;
p2 = RGW_CAP_READ;
EXPECT_TRUE (info.caps.check_cap(meta_caps, p1) == 0);
EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, p2) == 0);
p2 = RGW_CAP_WRITE;
EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, p2) != 0);
/*Version and tag infromation*/
EXPECT_TRUE(objv1->ver > objv->ver);
EXPECT_EQ(objv1->tag, objv->tag);
int rv = meta_caps_rm(perm);
EXPECT_EQ(0, rv);
if(rv == 0) {
g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(403U, g_test->get_resp_code());
}
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, meta_put){
JSONParser parser;
const char *perm = "*";
RGWUserInfo info;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, meta_caps_add(perm));
g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(parse_json_resp(parser) == 0);
RGWObjVersionTracker objv_tracker;
string metadata_key;
obj_version *objv = &objv_tracker.read_version;
JSONDecoder::decode_json("key", metadata_key, &parser);
JSONDecoder::decode_json("ver", *objv, &parser);
JSONObj *jo = parser.find_obj("data");
ASSERT_TRUE(jo);
string exp_meta_key = "user:";
exp_meta_key.append(uid);
EXPECT_TRUE(metadata_key.compare(exp_meta_key) == 0);
RGWUserInfo obt_info;
decode_json_obj(obt_info, jo);
/*Change the cap and PUT */
RGWUserCaps caps;
string new_cap;
Formatter *f = new JSONFormatter();
new_cap = meta_caps + string("=write");
caps.add_from_string(new_cap);
obt_info.caps = caps;
f->open_object_section("metadata_info");
::encode_json("key", metadata_key, f);
::encode_json("ver", *objv, f);
::encode_json("data", obt_info, f);
f->close_section();
std::stringstream ss;
f->flush(ss);
g_test->send_request(string("PUT"), (string("/admin/metadata/user?key=") + uid),
meta_read_json,
(void *)&ss, ss.str().length());
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, user_info(uid, display_name, obt_info));
uint32_t cp;
cp = RGW_CAP_WRITE;
EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, cp) == 0);
cp = RGW_CAP_READ;
EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, cp) != 0);
int rv = meta_caps_rm("write");
EXPECT_EQ(0, rv);
if(rv == 0) {
g_test->send_request(string("PUT"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(403U, g_test->get_resp_code());
}
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, meta_lock_unlock) {
const char *perm = "*";
string rest_req;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, meta_caps_add(perm));
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/metadata/user?lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/metadata/user?unlock&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
utime_t sleep_time(3, 0);
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(500U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(409U, g_test->get_resp_code());
sleep_time.sleep();
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph1";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, meta_caps_rm(perm));
perm = "read";
ASSERT_EQ(0, meta_caps_add(perm));
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, meta_caps_rm(perm));
perm = "write";
ASSERT_EQ(0, meta_caps_add(perm));
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, meta_caps_rm(perm));
rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
TEST(TestRGWAdmin, meta_delete){
JSONParser parser;
const char *perm = "*";
RGWUserInfo info;
ASSERT_EQ(0, user_create(uid, display_name));
ASSERT_EQ(0, meta_caps_add(perm));
g_test->send_request(string("DELETE"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_TRUE(user_info(uid, display_name, info) != 0);
ASSERT_EQ(0, user_create(uid, display_name));
perm = "read";
ASSERT_EQ(0, meta_caps_add(perm));
g_test->send_request(string("DELETE"), (string("/admin/metadata/user?key=") + uid));
EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, user_rm(uid, display_name));
}
int main(int argc, char *argv[]){
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_test = new admin_meta::test_helper();
finisher = new Finisher(g_ceph_context);
#ifdef GTEST
::testing::InitGoogleTest(&argc, argv);
#endif
finisher->start();
if(g_test->extract_input(argc, argv) < 0){
print_usage(argv[0]);
return -1;
}
#ifdef GTEST
int r = RUN_ALL_TESTS();
if (r >= 0) {
cout << "There are no failures in the test case\n";
} else {
cout << "There are some failures\n";
}
#endif
finisher->stop();
return 0;
}
| 28,954 | 30.302703 | 104 |
cc
|
null |
ceph-main/src/test/test_rgw_ldap.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "rgw_ldap.h"
#include "rgw_token.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
struct {
int argc;
char **argv;
} saved_args;
bool do_hexdump = false;
string access_key("ewogICAgIlJHV19UT0tFTiI6IHsKICAgICAgICAidmVyc2lvbiI6IDEsCiAgICAgICAgInR5cGUiOiAibGRhcCIsCiAgICAgICAgImlkIjogImFkbWluIiwKICAgICAgICAia2V5IjogImxpbnV4Ym94IgogICAgfQp9Cg=="); // {admin,linuxbox}
string other_key("ewogICAgIlJHV19UT0tFTiI6IHsKICAgICAgICAidmVyc2lvbiI6IDEsCiAgICAgICAgInR5cGUiOiAibGRhcCIsCiAgICAgICAgImlkIjogImFkbWluIiwKICAgICAgICAia2V5IjogImJhZHBhc3MiCiAgICB9Cn0K"); // {admin,badpass}
string ldap_uri = "ldaps://f23-kdc.rgw.com";
string ldap_binddn = "uid=admin,cn=users,cn=accounts,dc=rgw,dc=com";
string ldap_bindpw = "supersecret";
string ldap_searchdn = "cn=users,cn=accounts,dc=rgw,dc=com";
string ldap_searchfilter = "";
string ldap_dnattr = "uid";
rgw::LDAPHelper ldh(ldap_uri, ldap_binddn, ldap_bindpw, ldap_searchdn,
ldap_searchfilter, ldap_dnattr);
} /* namespace */
TEST(RGW_LDAP, INIT) {
int ret = ldh.init();
ASSERT_EQ(ret, 0);
}
TEST(RGW_LDAP, BIND) {
int ret = ldh.bind();
ASSERT_EQ(ret, 0);
}
TEST(RGW_LDAP, AUTH) {
using std::get;
using namespace rgw;
int ret = 0;
{
RGWToken token{from_base64(access_key)};
ret = ldh.auth(token.id, token.key);
ASSERT_EQ(ret, 0);
}
{
RGWToken token{from_base64(other_key)};
ret = ldh.auth(token.id, token.key);
ASSERT_NE(ret, 0);
}
}
TEST(RGW_LDAP, SHUTDOWN) {
// nothing
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if (access_key == "") {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 2,885 | 23.666667 | 212 |
cc
|
null |
ceph-main/src/test/test_rgw_token.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2016 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <errno.h>
#include <iostream>
#include <sstream>
#include <string>
#include "common/config.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "include/ceph_assert.h"
#include "gtest/gtest.h"
#include "rgw_token.h"
#include "rgw_b64.h"
#define dout_subsys ceph_subsys_rgw
namespace {
using namespace rgw;
using std::get;
using std::string;
string access_key{"Smonny"};
string secret_key{"Turjan of Miir"};
std::vector<RGWToken> tokens;
std::string enc_ad{"ewogICAgIlJHV19UT0tFTiI6IHsKICAgICAgICAidmVyc2lvbiI6IDEsCiAgICAgICAgInR5cGUiOiAiYWQiLAogICAgICAgICJpZCI6ICJTbW9ubnkiLAogICAgICAgICJrZXkiOiAiVHVyamFuIG9mIE1paXIiCiAgICB9Cn0K"};
std::string enc_ldap{"ewogICAgIlJHV19UT0tFTiI6IHsKICAgICAgICAidmVyc2lvbiI6IDEsCiAgICAgICAgInR5cGUiOiAibGRhcCIsCiAgICAgICAgImlkIjogIlNtb25ueSIsCiAgICAgICAgImtleSI6ICJUdXJqYW4gb2YgTWlpciIKICAgIH0KfQo="};
std::string non_base64{"stuff here"};
std::string non_base64_sploded{"90KLscc0Dz4U49HX-7Tx"};
Formatter* token_formatter{nullptr};
bool verbose {false};
}
using namespace std;
TEST(TOKEN, INIT) {
token_formatter = new JSONFormatter(true /* pretty */);
ASSERT_NE(token_formatter, nullptr);
}
TEST(TOKEN, ENCODE) {
// encode the two supported types
RGWToken token_ad(RGWToken::TOKEN_AD, access_key, secret_key);
ASSERT_EQ(token_ad.encode_json_base64(token_formatter), enc_ad);
tokens.push_back(token_ad); // provies copiable
RGWToken token_ldap(RGWToken::TOKEN_LDAP, access_key, secret_key);
ASSERT_EQ(token_ldap.encode_json_base64(token_formatter), enc_ldap);
tokens.push_back(token_ldap);
}
TEST(TOKEN, DECODE) {
for (const auto& enc_tok : {enc_ad, enc_ldap}) {
RGWToken token{from_base64(enc_tok)}; // decode ctor
ASSERT_EQ(token.id, access_key);
ASSERT_EQ(token.key, secret_key);
}
}
TEST(TOKEN, EMPTY) {
std::string empty{""};
RGWToken token{from_base64(empty)}; // decode ctor
ASSERT_FALSE(token.valid());
}
TEST(TOKEN, BADINPUT) {
RGWToken token{from_base64(non_base64)}; // decode ctor
ASSERT_FALSE(token.valid());
}
TEST(TOKEN, BADINPUT2) {
RGWToken token{from_base64(non_base64_sploded)}; // decode ctor
ASSERT_FALSE(token.valid());
}
TEST(TOKEN, BADINPUT3) {
try {
std::string stuff = from_base64(non_base64_sploded); // decode
} catch(...) {
// do nothing
}
ASSERT_EQ(1, 1);
}
TEST(TOKEN, SHUTDOWN) {
delete token_formatter;
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 3,222 | 24.784 | 203 |
cc
|
null |
ceph-main/src/test/test_rw.sh
|
#!/usr/bin/env bash
set -x
#
# Generic read/write from object store test
#
# Includes
source "`dirname $0`/test_common.sh"
TEST_POOL=rbd
# Functions
my_write_objects() {
write_objects $1 $2 10 1000000 $TEST_POOL
}
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
./vstart.sh -d -n || die "vstart.sh failed"
}
read_write_1_impl() {
write_objects 1 2 100 8192 $TEST_POOL
read_objects 2 100 8192
write_objects 3 3 10 81920 $TEST_POOL
read_objects 3 10 81920
write_objects 4 4 100 4 $TEST_POOL
read_objects 4 100 4
write_objects 1 2 100 8192 $TEST_POOL
read_objects 2 100 8192
# success
return 0
}
read_write_1() {
setup 3
read_write_1_impl
}
run() {
read_write_1 || die "test failed"
}
$@
| 854 | 14.833333 | 51 |
sh
|
null |
ceph-main/src/test/test_snap_mapper.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include <iterator>
#include <map>
#include <set>
#include <boost/scoped_ptr.hpp>
#include <sys/types.h>
#include <cstdlib>
#include "include/buffer.h"
#include "common/map_cacher.hpp"
#include "osd/osd_types_fmt.h"
#include "osd/SnapMapper.h"
#include "common/Cond.h"
#include "gtest/gtest.h"
using namespace std;
template <typename T>
typename T::iterator rand_choose(T &cont) {
if (std::empty(cont)) {
return std::end(cont);
}
return std::next(std::begin(cont), rand() % cont.size());
}
string random_string(size_t size)
{
string name;
for (size_t j = 0; j < size; ++j) {
name.push_back('a' + (rand() % 26));
}
return name;
}
class PausyAsyncMap : public MapCacher::StoreDriver<string, bufferlist> {
struct _Op {
virtual void operate(map<string, bufferlist> *store) = 0;
virtual ~_Op() {}
};
typedef std::shared_ptr<_Op> Op;
struct Remove : public _Op {
set<string> to_remove;
explicit Remove(const set<string> &to_remove) : to_remove(to_remove) {}
void operate(map<string, bufferlist> *store) override {
for (set<string>::iterator i = to_remove.begin();
i != to_remove.end();
++i) {
store->erase(*i);
}
}
};
struct Insert : public _Op {
map<string, bufferlist> to_insert;
explicit Insert(const map<string, bufferlist> &to_insert) : to_insert(to_insert) {}
void operate(map<string, bufferlist> *store) override {
for (map<string, bufferlist>::iterator i = to_insert.begin();
i != to_insert.end();
++i) {
store->erase(i->first);
store->insert(*i);
}
}
};
struct Callback : public _Op {
Context *context;
explicit Callback(Context *c) : context(c) {}
void operate(map<string, bufferlist> *store) override {
context->complete(0);
}
};
public:
class Transaction : public MapCacher::Transaction<string, bufferlist> {
friend class PausyAsyncMap;
list<Op> ops;
list<Op> callbacks;
public:
void set_keys(const map<string, bufferlist> &i) override {
ops.push_back(Op(new Insert(i)));
}
void remove_keys(const set<string> &r) override {
ops.push_back(Op(new Remove(r)));
}
void add_callback(Context *c) override {
callbacks.push_back(Op(new Callback(c)));
}
};
private:
ceph::mutex lock = ceph::make_mutex("PausyAsyncMap");
map<string, bufferlist> store;
class Doer : public Thread {
static const size_t MAX_SIZE = 100;
PausyAsyncMap *parent;
ceph::mutex lock = ceph::make_mutex("Doer lock");
ceph::condition_variable cond;
int stopping;
bool paused;
list<Op> queue;
public:
explicit Doer(PausyAsyncMap *parent) :
parent(parent), stopping(0), paused(false) {}
void *entry() override {
while (1) {
list<Op> ops;
{
std::unique_lock l{lock};
cond.wait(l, [this] {
return stopping || (!queue.empty() && !paused);
});
if (stopping && queue.empty()) {
stopping = 2;
cond.notify_all();
return 0;
}
ceph_assert(!queue.empty());
ceph_assert(!paused);
ops.swap(queue);
cond.notify_all();
}
ceph_assert(!ops.empty());
for (list<Op>::iterator i = ops.begin();
i != ops.end();
ops.erase(i++)) {
if (!(rand()%3))
usleep(1+(rand() % 5000));
std::lock_guard l{parent->lock};
(*i)->operate(&(parent->store));
}
}
}
void pause() {
std::lock_guard l{lock};
paused = true;
cond.notify_all();
}
void resume() {
std::lock_guard l{lock};
paused = false;
cond.notify_all();
}
void submit(list<Op> &in) {
std::unique_lock l{lock};
cond.wait(l, [this] { return queue.size() < MAX_SIZE;});
queue.splice(queue.end(), in, in.begin(), in.end());
cond.notify_all();
}
void stop() {
std::unique_lock l{lock};
stopping = 1;
cond.notify_all();
cond.wait(l, [this] { return stopping == 2; });
cond.notify_all();
}
} doer;
public:
PausyAsyncMap() : doer(this) {
doer.create("doer");
}
~PausyAsyncMap() override {
doer.join();
}
int get_keys(
const set<string> &keys,
map<string, bufferlist> *out) override {
std::lock_guard l{lock};
for (set<string>::const_iterator i = keys.begin();
i != keys.end();
++i) {
map<string, bufferlist>::iterator j = store.find(*i);
if (j != store.end())
out->insert(*j);
}
return 0;
}
int get_next(
const string &key,
pair<string, bufferlist> *next) override {
std::lock_guard l{lock};
map<string, bufferlist>::iterator j = store.upper_bound(key);
if (j != store.end()) {
if (next)
*next = *j;
return 0;
} else {
return -ENOENT;
}
}
int get_next_or_current(
const string &key,
pair<string, bufferlist> *next_or_current) override {
std::lock_guard l{lock};
map<string, bufferlist>::iterator j = store.lower_bound(key);
if (j != store.end()) {
if (next_or_current)
*next_or_current = *j;
return 0;
} else {
return -ENOENT;
}
}
void submit(Transaction *t) {
doer.submit(t->ops);
doer.submit(t->callbacks);
}
void flush() {
ceph::mutex lock = ceph::make_mutex("flush lock");
ceph::condition_variable cond;
bool done = false;
class OnFinish : public Context {
ceph::mutex *lock;
ceph::condition_variable *cond;
bool *done;
public:
OnFinish(ceph::mutex *lock, ceph::condition_variable *cond, bool *done)
: lock(lock), cond(cond), done(done) {}
void finish(int) override {
std::lock_guard l{*lock};
*done = true;
cond->notify_all();
}
};
Transaction t;
t.add_callback(new OnFinish(&lock, &cond, &done));
submit(&t);
{
std::unique_lock l{lock};
cond.wait(l, [&] { return done; });
}
}
void pause() {
doer.pause();
}
void resume() {
doer.resume();
}
void stop() {
doer.stop();
}
};
class MapCacherTest : public ::testing::Test {
protected:
boost::scoped_ptr< PausyAsyncMap > driver;
boost::scoped_ptr<MapCacher::MapCacher<string, bufferlist> > cache;
map<string, bufferlist> truth;
set<string> names;
public:
void assert_bl_eq(bufferlist &bl1, bufferlist &bl2) {
ASSERT_EQ(bl1.length(), bl2.length());
bufferlist::iterator j = bl2.begin();
for (bufferlist::iterator i = bl1.begin();
!i.end();
++i, ++j) {
ASSERT_TRUE(!j.end());
ASSERT_EQ(*i, *j);
}
}
void assert_bl_map_eq(map<string, bufferlist> &m1,
map<string, bufferlist> &m2) {
ASSERT_EQ(m1.size(), m2.size());
map<string, bufferlist>::iterator j = m2.begin();
for (map<string, bufferlist>::iterator i = m1.begin();
i != m1.end();
++i, ++j) {
ASSERT_TRUE(j != m2.end());
ASSERT_EQ(i->first, j->first);
assert_bl_eq(i->second, j->second);
}
}
size_t random_num() {
return random() % 10;
}
size_t random_size() {
return random() % 1000;
}
void random_bl(size_t size, bufferlist *bl) {
for (size_t i = 0; i < size; ++i) {
bl->append(rand());
}
}
void do_set() {
size_t set_size = random_num();
map<string, bufferlist> to_set;
for (size_t i = 0; i < set_size; ++i) {
bufferlist bl;
random_bl(random_size(), &bl);
string key = *rand_choose(names);
to_set.insert(
make_pair(key, bl));
}
for (map<string, bufferlist>::iterator i = to_set.begin();
i != to_set.end();
++i) {
truth.erase(i->first);
truth.insert(*i);
}
{
PausyAsyncMap::Transaction t;
cache->set_keys(to_set, &t);
driver->submit(&t);
}
}
void remove() {
size_t remove_size = random_num();
set<string> to_remove;
for (size_t i = 0; i < remove_size ; ++i) {
to_remove.insert(*rand_choose(names));
}
for (set<string>::iterator i = to_remove.begin();
i != to_remove.end();
++i) {
truth.erase(*i);
}
{
PausyAsyncMap::Transaction t;
cache->remove_keys(to_remove, &t);
driver->submit(&t);
}
}
void get() {
set<string> to_get;
size_t get_size = random_num();
for (size_t i = 0; i < get_size; ++i) {
to_get.insert(*rand_choose(names));
}
map<string, bufferlist> got_truth;
for (set<string>::iterator i = to_get.begin();
i != to_get.end();
++i) {
map<string, bufferlist>::iterator j = truth.find(*i);
if (j != truth.end())
got_truth.insert(*j);
}
map<string, bufferlist> got;
cache->get_keys(to_get, &got);
assert_bl_map_eq(got, got_truth);
}
void get_next() {
string cur;
while (true) {
pair<string, bufferlist> next;
int r = cache->get_next(cur, &next);
pair<string, bufferlist> next_truth;
map<string, bufferlist>::iterator i = truth.upper_bound(cur);
int r_truth = (i == truth.end()) ? -ENOENT : 0;
if (i != truth.end())
next_truth = *i;
ASSERT_EQ(r, r_truth);
if (r == -ENOENT)
break;
ASSERT_EQ(next.first, next_truth.first);
assert_bl_eq(next.second, next_truth.second);
cur = next.first;
}
}
void SetUp() override {
driver.reset(new PausyAsyncMap());
cache.reset(new MapCacher::MapCacher<string, bufferlist>(driver.get()));
names.clear();
truth.clear();
size_t names_size(random_num() + 10);
for (size_t i = 0; i < names_size; ++i) {
names.insert(random_string(1 + (random_size() % 10)));
}
}
void TearDown() override {
driver->stop();
cache.reset();
driver.reset();
}
};
TEST_F(MapCacherTest, Simple)
{
driver->pause();
map<string, bufferlist> truth;
set<string> truth_keys;
string blah("asdf");
bufferlist bl;
encode(blah, bl);
truth[string("asdf")] = bl;
truth_keys.insert(truth.begin()->first);
{
PausyAsyncMap::Transaction t;
cache->set_keys(truth, &t);
driver->submit(&t);
cache->set_keys(truth, &t);
driver->submit(&t);
}
map<string, bufferlist> got;
cache->get_keys(truth_keys, &got);
assert_bl_map_eq(got, truth);
driver->resume();
sleep(1);
got.clear();
cache->get_keys(truth_keys, &got);
assert_bl_map_eq(got, truth);
}
TEST_F(MapCacherTest, Random)
{
for (size_t i = 0; i < 5000; ++i) {
if (!(i % 50)) {
std::cout << "On iteration " << i << std::endl;
}
switch (rand() % 4) {
case 0:
get();
break;
case 1:
do_set();
break;
case 2:
get_next();
break;
case 3:
remove();
break;
}
}
}
class MapperVerifier {
PausyAsyncMap *driver;
boost::scoped_ptr< SnapMapper > mapper;
map<snapid_t, set<hobject_t> > snap_to_hobject;
map<hobject_t, set<snapid_t>> hobject_to_snap;
snapid_t next;
uint32_t mask;
uint32_t bits;
ceph::mutex lock = ceph::make_mutex("lock");
public:
MapperVerifier(
PausyAsyncMap *driver,
uint32_t mask,
uint32_t bits)
: driver(driver),
mapper(new SnapMapper(g_ceph_context, driver, mask, bits, 0, shard_id_t(1))),
mask(mask), bits(bits) {}
hobject_t random_hobject() {
return hobject_t(
random_string(1+(rand() % 16)),
random_string(1+(rand() % 16)),
snapid_t(rand() % 1000),
(rand() & ((~0)<<bits)) | (mask & ~((~0)<<bits)),
0, random_string(rand() % 16));
}
void choose_random_snaps(int num, set<snapid_t> *snaps) {
ceph_assert(snaps);
ceph_assert(!snap_to_hobject.empty());
for (int i = 0; i < num || snaps->empty(); ++i) {
snaps->insert(rand_choose(snap_to_hobject)->first);
}
}
void create_snap() {
snap_to_hobject[next];
++next;
}
void create_object() {
std::lock_guard l{lock};
if (snap_to_hobject.empty())
return;
hobject_t obj;
do {
obj = random_hobject();
} while (hobject_to_snap.count(obj));
set<snapid_t> &snaps = hobject_to_snap[obj];
choose_random_snaps(1 + (rand() % 20), &snaps);
for (set<snapid_t>::iterator i = snaps.begin();
i != snaps.end();
++i) {
map<snapid_t, set<hobject_t> >::iterator j = snap_to_hobject.find(*i);
ceph_assert(j != snap_to_hobject.end());
j->second.insert(obj);
}
{
PausyAsyncMap::Transaction t;
mapper->add_oid(obj, snaps, &t);
driver->submit(&t);
}
}
std::pair<std::string, ceph::buffer::list> to_raw(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_raw(to_map);
}
std::string to_legacy_raw_key(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_legacy_raw_key(to_map);
}
template <typename... Args>
std::string to_object_key(Args&&... args) {
return mapper->to_object_key(std::forward<Args>(args)...);
}
std::string to_raw_key(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_raw_key(to_map);
}
template <typename... Args>
std::string make_purged_snap_key(Args&&... args) {
return mapper->make_purged_snap_key(std::forward<Args>(args)...);
}
void trim_snap() {
std::lock_guard l{lock};
if (snap_to_hobject.empty())
return;
map<snapid_t, set<hobject_t> >::iterator snap =
rand_choose(snap_to_hobject);
set<hobject_t> hobjects = snap->second;
vector<hobject_t> hoids;
while (mapper->get_next_objects_to_trim(
snap->first, rand() % 5 + 1, &hoids) == 0) {
for (auto &&hoid: hoids) {
ceph_assert(!hoid.is_max());
ceph_assert(hobjects.count(hoid));
hobjects.erase(hoid);
map<hobject_t, set<snapid_t>>::iterator j =
hobject_to_snap.find(hoid);
ceph_assert(j->second.count(snap->first));
set<snapid_t> old_snaps(j->second);
j->second.erase(snap->first);
{
PausyAsyncMap::Transaction t;
mapper->update_snaps(
hoid,
j->second,
&old_snaps,
&t);
driver->submit(&t);
}
if (j->second.empty()) {
hobject_to_snap.erase(j);
}
hoid = hobject_t::get_max();
}
hoids.clear();
}
ceph_assert(hobjects.empty());
snap_to_hobject.erase(snap);
}
void remove_oid() {
std::lock_guard l{lock};
if (hobject_to_snap.empty())
return;
map<hobject_t, set<snapid_t>>::iterator obj =
rand_choose(hobject_to_snap);
for (set<snapid_t>::iterator i = obj->second.begin();
i != obj->second.end();
++i) {
map<snapid_t, set<hobject_t> >::iterator j =
snap_to_hobject.find(*i);
ceph_assert(j->second.count(obj->first));
j->second.erase(obj->first);
}
{
PausyAsyncMap::Transaction t;
mapper->remove_oid(
obj->first,
&t);
driver->submit(&t);
}
hobject_to_snap.erase(obj);
}
void check_oid() {
std::lock_guard l{lock};
if (hobject_to_snap.empty())
return;
map<hobject_t, set<snapid_t>>::iterator obj =
rand_choose(hobject_to_snap);
set<snapid_t> snaps;
int r = mapper->get_snaps(obj->first, &snaps);
ceph_assert(r == 0);
ASSERT_EQ(snaps, obj->second);
}
};
class SnapMapperTest : public ::testing::Test {
protected:
boost::scoped_ptr< PausyAsyncMap > driver;
map<pg_t, std::shared_ptr<MapperVerifier> > mappers;
uint32_t pgnum;
void SetUp() override {
driver.reset(new PausyAsyncMap());
pgnum = 0;
}
void TearDown() override {
driver->stop();
mappers.clear();
driver.reset();
}
MapperVerifier &get_tester() {
//return *(mappers.begin()->second);
return *(rand_choose(mappers)->second);
}
void init(uint32_t to_set) {
pgnum = to_set;
for (uint32_t i = 0; i < pgnum; ++i) {
pg_t pgid(i, 0);
mappers[pgid].reset(
new MapperVerifier(
driver.get(),
i,
pgid.get_split_bits(pgnum)
)
);
}
}
void run() {
for (int i = 0; i < 5000; ++i) {
if (!(i % 50))
std::cout << i << std::endl;
switch (rand() % 5) {
case 0:
get_tester().create_snap();
break;
case 1:
get_tester().create_object();
break;
case 2:
get_tester().trim_snap();
break;
case 3:
get_tester().check_oid();
break;
case 4:
get_tester().remove_oid();
break;
}
}
}
};
TEST_F(SnapMapperTest, Simple) {
init(1);
get_tester().create_snap();
get_tester().create_object();
get_tester().trim_snap();
}
TEST_F(SnapMapperTest, More) {
init(1);
run();
}
TEST_F(SnapMapperTest, MultiPG) {
init(50);
run();
}
// Check to_object_key against current format to detect accidental changes in encoding
TEST_F(SnapMapperTest, CheckObjectKeyFormat) {
init(1);
// <object, test_raw_key>
std::vector<std::tuple<hobject_t, std::string>> object_to_object_key({
{hobject_t{"test_object", "", 20, 0x01234567, 20, ""},
"OBJ_.1_0000000000000014.76543210.14.test%uobject.."},
{hobject_t{"test._ob.ject", "k.ey", 20, 0x01234567, 20, ""},
"OBJ_.1_0000000000000014.76543210.14.test%e%uob%eject.k%eey."},
{hobject_t{"test_object", "", 20, 0x01234567, 20, "namespace"},
"OBJ_.1_0000000000000014.76543210.14.test%uobject..namespace"},
{hobject_t{
"test_object", "", std::numeric_limits<snapid_t>::max() - 20, 0x01234567,
std::numeric_limits<int64_t>::max() - 20, "namespace"},
"OBJ_.1_7FFFFFFFFFFFFFEB.76543210.ffffffffffffffec.test%uobject..namespace"}
});
for (auto &[object, test_object_key]: object_to_object_key) {
auto object_key = get_tester().to_object_key(object);
if (object_key != test_object_key) {
std::cout << object << " should be "
<< test_object_key << " is "
<< get_tester().to_object_key(object)
<< std::endl;
}
ASSERT_EQ(object_key, test_object_key);
}
}
// Check to_raw_key against current format to detect accidental changes in encoding
TEST_F(SnapMapperTest, CheckRawKeyFormat) {
init(1);
// <object, snapid, test_raw_key>
std::vector<std::tuple<hobject_t, snapid_t, std::string>> object_to_raw_key({
{hobject_t{"test_object", "", 20, 0x01234567, 20, ""}, 25,
"SNA_20_0000000000000019_.1_0000000000000014.76543210.14.test%uobject.."},
{hobject_t{"test._ob.ject", "k.ey", 20, 0x01234567, 20, ""}, 25,
"SNA_20_0000000000000019_.1_0000000000000014.76543210.14.test%e%uob%eject.k%eey."},
{hobject_t{"test_object", "", 20, 0x01234567, 20, "namespace"}, 25,
"SNA_20_0000000000000019_.1_0000000000000014.76543210.14.test%uobject..namespace"},
{hobject_t{
"test_object", "", std::numeric_limits<snapid_t>::max() - 20, 0x01234567,
std::numeric_limits<int64_t>::max() - 20, "namespace"}, std::numeric_limits<snapid_t>::max() - 20,
"SNA_9223372036854775787_FFFFFFFFFFFFFFEC_.1_7FFFFFFFFFFFFFEB.76543210.ffffffffffffffec.test%uobject..namespace"}
});
for (auto &[object, snap, test_raw_key]: object_to_raw_key) {
auto raw_key = get_tester().to_raw_key(std::make_pair(snap, object));
if (raw_key != test_raw_key) {
std::cout << object << " " << snap << " should be "
<< test_raw_key << " is "
<< get_tester().to_raw_key(std::make_pair(snap, object))
<< std::endl;
}
ASSERT_EQ(raw_key, test_raw_key);
}
}
// Check make_purged_snap_key against current format to detect accidental changes
// in encoding
TEST_F(SnapMapperTest, CheckMakePurgedSnapKeyFormat) {
init(1);
// <pool, snap, test_key>
std::vector<std::tuple<int64_t, snapid_t, std::string>> purged_snap_to_key({
{20, 30, "PSN__20_000000000000001e"},
{std::numeric_limits<int64_t>::max() - 20,
std::numeric_limits<snapid_t>::max() - 20,
"PSN__9223372036854775787_ffffffffffffffec"}
});
for (auto &[pool, snap, test_key]: purged_snap_to_key) {
auto raw_purged_snap_key = get_tester().make_purged_snap_key(pool, snap);
if (raw_purged_snap_key != test_key) {
std::cout << "<" << pool << ", " << snap << "> should be " << test_key
<< " is " << raw_purged_snap_key << std::endl;
}
// retesting (mostly for test numbers accounting)
ASSERT_EQ(raw_purged_snap_key, test_key);
}
}
TEST_F(SnapMapperTest, LegacyKeyConvertion) {
init(1);
auto obj = get_tester().random_hobject();
snapid_t snapid = random() % 10;
auto snap_obj = make_pair(snapid, obj);
auto raw = get_tester().to_raw(snap_obj);
std::string old_key = get_tester().to_legacy_raw_key(snap_obj);
std::string converted_key =
SnapMapper::convert_legacy_key(old_key, raw.second);
std::string new_key = get_tester().to_raw_key(snap_obj);
if (converted_key != new_key) {
std::cout << "Converted: " << old_key << "\nTo: " << converted_key
<< "\nNew key: " << new_key << std::endl;
}
ASSERT_EQ(converted_key, new_key);
}
/**
* 'DirectMapper' provides simple, controlled, interface to the underlying
* SnapMapper.
*/
class DirectMapper {
public:
std::unique_ptr<PausyAsyncMap> driver{make_unique<PausyAsyncMap>()};
std::unique_ptr<SnapMapper> mapper;
uint32_t mask;
uint32_t bits;
ceph::mutex lock = ceph::make_mutex("lock");
DirectMapper(
uint32_t mask,
uint32_t bits)
: mapper(new SnapMapper(g_ceph_context, driver.get(), mask, bits, 0, shard_id_t(1))),
mask(mask), bits(bits) {}
hobject_t random_hobject() {
return hobject_t(
random_string(1+(rand() % 16)),
random_string(1+(rand() % 16)),
snapid_t(rand() % 1000),
(rand() & ((~0)<<bits)) | (mask & ~((~0)<<bits)),
0, random_string(rand() % 16));
}
void create_object(const hobject_t& obj, const set<snapid_t> &snaps) {
std::lock_guard l{lock};
PausyAsyncMap::Transaction t;
mapper->add_oid(obj, snaps, &t);
driver->submit(&t);
}
std::pair<std::string, ceph::buffer::list> to_raw(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_raw(to_map);
}
std::string to_legacy_raw_key(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_legacy_raw_key(to_map);
}
std::string to_raw_key(
const std::pair<snapid_t, hobject_t> &to_map) {
return mapper->to_raw_key(to_map);
}
void shorten_mapping_key(snapid_t snap, const hobject_t &clone)
{
// calculate the relevant key
std::string k = mapper->to_raw_key(snap, clone);
// find the value for this key
map<string, bufferlist> kvmap;
auto r = mapper->backend.get_keys(set{k}, &kvmap);
ASSERT_GE(r, 0);
// replace the key with its shortened version
PausyAsyncMap::Transaction t;
mapper->backend.remove_keys(set{k}, &t);
auto short_k = k.substr(0, 10);
mapper->backend.set_keys(map<string, bufferlist>{{short_k, kvmap[k]}}, &t);
driver->submit(&t);
driver->flush();
}
};
class DirectMapperTest : public ::testing::Test {
public:
// ctor & initialization
DirectMapperTest() = default;
~DirectMapperTest() = default;
void SetUp() override;
void TearDown() override;
protected:
std::unique_ptr<DirectMapper> direct;
};
void DirectMapperTest::SetUp()
{
direct = std::make_unique<DirectMapper>(0, 0);
}
void DirectMapperTest::TearDown()
{
direct->driver->stop();
direct->mapper.reset();
direct->driver.reset();
}
TEST_F(DirectMapperTest, BasciObject)
{
auto obj = direct->random_hobject();
set<snapid_t> snaps{100, 200};
direct->create_object(obj, snaps);
// verify that the OBJ_ & SNA_ entries are there
auto osn1 = direct->mapper->get_snaps(obj);
ASSERT_EQ(snaps, osn1);
auto vsn1 = direct->mapper->get_snaps_check_consistency(obj);
ASSERT_EQ(snaps, vsn1);
}
TEST_F(DirectMapperTest, CorruptedSnaRecord)
{
object_t base_name{"obj"};
std::string key{"key"};
hobject_t head{base_name, key, CEPH_NOSNAP, 0x17, 0, ""};
hobject_t cln1{base_name, key, 10, 0x17, 0, ""};
hobject_t cln2{base_name, key, 20, 0x17, 0, ""}; // the oldest version
set<snapid_t> head_snaps{400, 500};
set<snapid_t> cln1_snaps{300};
set<snapid_t> cln2_snaps{100, 200};
PausyAsyncMap::Transaction t;
direct->mapper->add_oid(head, head_snaps, &t);
direct->mapper->add_oid(cln1, cln1_snaps, &t);
direct->mapper->add_oid(cln2, cln2_snaps, &t);
direct->driver->submit(&t);
direct->driver->flush();
// verify that the OBJ_ & SNA_ entries are there
{
auto osn1 = direct->mapper->get_snaps(cln1);
EXPECT_EQ(cln1_snaps, osn1);
auto osn2 = direct->mapper->get_snaps(cln2);
EXPECT_EQ(cln2_snaps, osn2);
auto osnh = direct->mapper->get_snaps(head);
EXPECT_EQ(head_snaps, osnh);
}
{
auto vsn1 = direct->mapper->get_snaps_check_consistency(cln1);
EXPECT_EQ(cln1_snaps, vsn1);
auto vsn2 = direct->mapper->get_snaps_check_consistency(cln2);
EXPECT_EQ(cln2_snaps, vsn2);
auto vsnh = direct->mapper->get_snaps_check_consistency(head);
EXPECT_EQ(head_snaps, vsnh);
}
// corrupt the SNA_ entry for cln1
direct->shorten_mapping_key(300, cln1);
{
auto vsnh = direct->mapper->get_snaps_check_consistency(head);
EXPECT_EQ(head_snaps, vsnh);
auto vsn1 = direct->mapper->get_snaps(cln1);
EXPECT_EQ(cln1_snaps, vsn1);
auto osn1 = direct->mapper->get_snaps_check_consistency(cln1);
EXPECT_NE(cln1_snaps, osn1);
auto vsn2 = direct->mapper->get_snaps_check_consistency(cln2);
EXPECT_EQ(cln2_snaps, vsn2);
}
}
///\todo test the case of a corrupted OBJ_ entry
| 25,223 | 25.467996 | 116 |
cc
|
null |
ceph-main/src/test/test_split.sh
|
#!/usr/bin/env bash
set -x
#
# Add some objects to the data PGs, and then test splitting those PGs
#
# Includes
source "`dirname $0`/test_common.sh"
TEST_POOL=rbd
# Constants
my_write_objects() {
write_objects $1 $2 10 1000000 $TEST_POOL
}
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
./vstart.sh -d -n
}
get_pgp_num() {
./ceph -c ./ceph.conf osd pool get $TEST_POOL pgp_num > $TEMPDIR/pgp_num
[ $? -eq 0 ] || die "failed to get pgp_num"
PGP_NUM=`grep PGP_NUM $TEMPDIR/pgp_num | sed 's/.*PGP_NUM:\([ 0123456789]*\).*$/\1/'`
}
split1_impl() {
# Write lots and lots of objects
my_write_objects 1 2
get_pgp_num
echo "\$PGP_NUM=$PGP_NUM"
# Double the number of PGs
PGP_NUM=$((PGP_NUM*2))
echo "doubling PGP_NUM to $PGP_NUM..."
./ceph -c ./ceph.conf osd pool set $TEST_POOL pgp_num $PGP_NUM
sleep 30
# success
return 0
}
split1() {
setup 2
split1_impl
}
many_pools() {
setup 3
for i in `seq 1 3000`; do
./ceph -c ./ceph.conf osd pool create "pool${i}" 8 || die "pool create failed"
done
my_write_objects 1 10
}
run() {
split1 || die "test failed"
}
$@
| 1,299 | 17.84058 | 94 |
sh
|
null |
ceph-main/src/test/test_str_list.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/str_list.h"
#include "gtest/gtest.h"
// SplitTest is parameterized for list/vector/set
using Types = ::testing::Types<std::list<std::string>,
std::vector<std::string>>;
template <typename T>
struct SplitTest : ::testing::Test {
void test(const char* input, const char *delim,
const std::list<std::string>& expected) {
EXPECT_EQ(expected, get_str_list(input, delim));
}
void test(const char* input, const char *delim,
const std::vector<std::string>& expected) {
EXPECT_EQ(expected, get_str_vec(input, delim));
}
};
TYPED_TEST_SUITE(SplitTest, Types);
TYPED_TEST(SplitTest, Get)
{
this->test("", " ", TypeParam{});
this->test(" ", " ", TypeParam{});
this->test("foo", " ", TypeParam{"foo"});
this->test("foo bar", " ", TypeParam{"foo","bar"});
this->test(" foo bar", " ", TypeParam{"foo","bar"});
this->test("foo bar ", " ", TypeParam{"foo","bar"});
this->test("foo bar ", " ", TypeParam{"foo","bar"});
// default delimiter
const char *delims = ";,= \t";
this->test(" ; , = \t ", delims, TypeParam{});
this->test(" ; foo = \t ", delims, TypeParam{"foo"});
this->test("a,b,c", delims, TypeParam{"a","b","c"});
this->test("a\tb\tc\t", delims, TypeParam{"a","b","c"});
this->test("a, b, c", delims, TypeParam{"a","b","c"});
this->test("a b c", delims, TypeParam{"a","b","c"});
this->test("a=b=c", delims, TypeParam{"a","b","c"});
}
| 1,553 | 32.782609 | 70 |
cc
|
null |
ceph-main/src/test/test_stress_watch.cc
|
#include "include/rados/librados.h"
#include "include/rados/librados.hpp"
#include "include/utime.h"
#include "common/Thread.h"
#include "common/Clock.h"
#include "test/librados/test_cxx.h"
#include "gtest/gtest.h"
#include <semaphore.h>
#include <errno.h>
#include <map>
#include <sstream>
#include <iostream>
#include <string>
#include <atomic>
#include "test/librados/testcase_cxx.h"
using namespace librados;
using std::map;
using std::ostringstream;
using std::string;
static sem_t sem;
static std::atomic<bool> stop_flag = { false };
class WatchNotifyTestCtx : public WatchCtx
{
public:
void notify(uint8_t opcode, uint64_t ver, bufferlist& bl) override
{
sem_post(&sem);
}
};
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
struct WatcherUnwatcher : public Thread {
string pool;
explicit WatcherUnwatcher(string& _pool) : pool(_pool) {}
void *entry() override {
Rados cluster;
connect_cluster_pp(cluster);
while (!stop_flag) {
IoCtx ioctx;
cluster.ioctx_create(pool.c_str(), ioctx);
uint64_t handle;
WatchNotifyTestCtx watch_ctx;
int r = ioctx.watch("foo", 0, &handle, &watch_ctx);
if (r == 0)
ioctx.unwatch("foo", handle);
ioctx.close();
}
return NULL;
}
};
typedef RadosTestParamPP WatchStress;
INSTANTIATE_TEST_SUITE_P(WatchStressTests, WatchStress,
::testing::Values("", "cache"));
TEST_P(WatchStress, Stress1) {
ASSERT_EQ(0, sem_init(&sem, 0, 0));
Rados ncluster;
std::string pool_name = get_temp_pool_name();
ASSERT_EQ("", create_one_pool_pp(pool_name, ncluster));
IoCtx nioctx;
ncluster.ioctx_create(pool_name.c_str(), nioctx);
WatcherUnwatcher *thr = new WatcherUnwatcher(pool_name);
thr->create("watcher_unwatch");
ASSERT_EQ(0, nioctx.create("foo", false));
for (unsigned i = 0; i < 75; ++i) {
std::cerr << "Iteration " << i << std::endl;
uint64_t handle;
Rados cluster;
IoCtx ioctx;
WatchNotifyTestCtx ctx;
connect_cluster_pp(cluster);
cluster.ioctx_create(pool_name.c_str(), ioctx);
ASSERT_EQ(0, ioctx.watch("foo", 0, &handle, &ctx));
bool do_blocklist = i % 2;
if (do_blocklist) {
cluster.test_blocklist_self(true);
std::cerr << "blocklisted" << std::endl;
sleep(1);
}
bufferlist bl2;
ASSERT_EQ(0, nioctx.notify("foo", 0, bl2));
if (do_blocklist) {
sleep(1); // Give a change to see an incorrect notify
} else {
TestAlarm alarm;
sem_wait(&sem);
}
if (do_blocklist) {
cluster.test_blocklist_self(false);
}
ioctx.unwatch("foo", handle);
ioctx.close();
}
stop_flag = true;
thr->join();
nioctx.close();
ASSERT_EQ(0, destroy_one_pool_pp(pool_name, ncluster));
sem_destroy(&sem);
}
#pragma GCC diagnostic pop
#pragma GCC diagnostic warning "-Wpragmas"
| 2,922 | 22.572581 | 70 |
cc
|
null |
ceph-main/src/test/test_striper.cc
|
#include "gtest/gtest.h"
#include "global/global_context.h"
#include "osdc/Striper.h"
using namespace std;
TEST(Striper, Stripe1)
{
file_layout_t l;
l.object_size = 262144;
l.stripe_unit = 4096;
l.stripe_count = 3;
vector<ObjectExtent> ex;
Striper::file_to_extents(g_ceph_context, 1, &l, 5006035, 46419, 5006035, ex);
cout << "result " << ex << std::endl;
ASSERT_EQ(3u, ex.size());
ASSERT_EQ(98304u, ex[0].truncate_size);
ASSERT_EQ(ex[1].offset, ex[1].truncate_size);
ASSERT_EQ(94208u, ex[2].truncate_size);
}
TEST(Striper, EmptyPartialResult)
{
file_layout_t l;
l.object_size = 4194304;
l.stripe_unit = 4194304;
l.stripe_count = 1;
vector<ObjectExtent> ex;
Striper::file_to_extents(g_ceph_context, 1, &l, 725549056, 131072, 72554905600, ex);
cout << "ex " << ex << std::endl;
ASSERT_EQ(2u, ex.size());
Striper::StripedReadResult r;
bufferlist bl;
r.add_partial_result(g_ceph_context, bl, ex[1].buffer_extents);
bufferptr bp(65536);
bp.zero();
bl.append(bp);
r.add_partial_result(g_ceph_context, bl, ex[0].buffer_extents);
bufferlist outbl;
r.assemble_result(g_ceph_context, outbl, false);
ASSERT_EQ(65536u, outbl.length());
}
TEST(Striper, GetNumObj)
{
file_layout_t l;
l.object_size = 262144;
l.stripe_unit = 4096;
l.stripe_count = 3;
uint64_t size,numobjs;
size = 6999;
numobjs = Striper::get_num_objects(l, size);
ASSERT_EQ(2u, numobjs);
size = 793320;
numobjs = Striper::get_num_objects(l, size);
ASSERT_EQ(5u, numobjs);
size = 805608;
numobjs = Striper::get_num_objects(l, size);
ASSERT_EQ(6u, numobjs);
}
TEST(Striper, GetFileOffset)
{
file_layout_t l;
l.object_size = 262144;
l.stripe_unit = 4096;
l.stripe_count = 3;
uint64_t object_no = 100;
uint64_t object_off = 200000;
uint64_t file_offset = Striper::get_file_offset(
g_ceph_context, &l, object_no, object_off);
ASSERT_EQ(26549568u, file_offset);
}
| 1,945 | 20.622222 | 86 |
cc
|
null |
ceph-main/src/test/test_subprocess.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2015 Mirantis Inc
*
* Author: Mykola Golub <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <unistd.h>
#include <iostream>
#include "common/SubProcess.h"
#include "common/safe_io.h"
#include "gtest/gtest.h"
#include "common/fork_function.h"
#ifdef _WIN32
// Some of the tests expect GNU binaries to be available. We'll just rely on
// the ones provided by Msys (which also comes with Git for Windows).
#define SHELL "bash.exe"
#else
#define SHELL "/bin/sh"
#endif
bool read_from_fd(int fd, std::string &out) {
out.clear();
char buf[1024];
ssize_t n = safe_read(fd, buf, sizeof(buf) - 1);
if (n < 0)
return false;
buf[n] = '\0';
out = buf;
return true;
}
TEST(SubProcess, True)
{
SubProcess p("true");
ASSERT_EQ(p.spawn(), 0);
ASSERT_EQ(p.join(), 0);
ASSERT_TRUE(p.err().c_str()[0] == '\0');
}
TEST(SubProcess, False)
{
SubProcess p("false");
ASSERT_EQ(p.spawn(), 0);
ASSERT_EQ(p.join(), 1);
ASSERT_FALSE(p.err().c_str()[0] == '\0');
}
TEST(SubProcess, NotFound)
{
SubProcess p("NOTEXISTENTBINARY", SubProcess::CLOSE, SubProcess::CLOSE, SubProcess::PIPE);
#ifdef _WIN32
// Windows will error out early.
ASSERT_EQ(p.spawn(), -1);
#else
ASSERT_EQ(p.spawn(), 0);
std::string buf;
ASSERT_TRUE(read_from_fd(p.get_stderr(), buf));
std::cerr << "stderr: " << buf;
ASSERT_EQ(p.join(), 1);
std::cerr << "err: " << p.err() << std::endl;
ASSERT_FALSE(p.err().c_str()[0] == '\0');
#endif
}
TEST(SubProcess, Echo)
{
SubProcess echo("echo", SubProcess::CLOSE, SubProcess::PIPE);
echo.add_cmd_args("1", "2", "3", NULL);
ASSERT_EQ(echo.spawn(), 0);
std::string buf;
ASSERT_TRUE(read_from_fd(echo.get_stdout(), buf));
std::cerr << "stdout: " << buf;
ASSERT_EQ(buf, "1 2 3\n");
ASSERT_EQ(echo.join(), 0);
ASSERT_TRUE(echo.err().c_str()[0] == '\0');
}
TEST(SubProcess, Cat)
{
SubProcess cat("cat", SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE);
ASSERT_EQ(cat.spawn(), 0);
std::string msg("to my, trociny!");
int n = write(cat.get_stdin(), msg.c_str(), msg.size());
ASSERT_EQ(n, (int)msg.size());
cat.close_stdin();
std::string buf;
ASSERT_TRUE(read_from_fd(cat.get_stdout(), buf));
std::cerr << "stdout: " << buf << std::endl;
ASSERT_EQ(buf, msg);
ASSERT_TRUE(read_from_fd(cat.get_stderr(), buf));
ASSERT_EQ(buf, "");
ASSERT_EQ(cat.join(), 0);
ASSERT_TRUE(cat.err().c_str()[0] == '\0');
}
TEST(SubProcess, CatDevNull)
{
SubProcess cat("cat", SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE);
cat.add_cmd_arg("/dev/null");
ASSERT_EQ(cat.spawn(), 0);
std::string buf;
ASSERT_TRUE(read_from_fd(cat.get_stdout(), buf));
ASSERT_EQ(buf, "");
ASSERT_TRUE(read_from_fd(cat.get_stderr(), buf));
ASSERT_EQ(buf, "");
ASSERT_EQ(cat.join(), 0);
ASSERT_TRUE(cat.err().c_str()[0] == '\0');
}
TEST(SubProcess, Killed)
{
SubProcessTimed cat("cat", SubProcess::PIPE, SubProcess::PIPE);
ASSERT_EQ(cat.spawn(), 0);
cat.kill();
ASSERT_EQ(cat.join(), 128 + SIGTERM);
std::cerr << "err: " << cat.err() << std::endl;
ASSERT_FALSE(cat.err().c_str()[0] == '\0');
}
#ifndef _WIN32
TEST(SubProcess, CatWithArgs)
{
SubProcess cat("cat", SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE);
cat.add_cmd_args("/dev/stdin", "/dev/null", "/NOTEXIST", NULL);
ASSERT_EQ(cat.spawn(), 0);
std::string msg("Hello, Word!");
int n = write(cat.get_stdin(), msg.c_str(), msg.size());
ASSERT_EQ(n, (int)msg.size());
cat.close_stdin();
std::string buf;
ASSERT_TRUE(read_from_fd(cat.get_stdout(), buf));
std::cerr << "stdout: " << buf << std::endl;
ASSERT_EQ(buf, msg);
ASSERT_TRUE(read_from_fd(cat.get_stderr(), buf));
std::cerr << "stderr: " << buf;
ASSERT_FALSE(buf.empty());
ASSERT_EQ(cat.join(), 1);
std::cerr << "err: " << cat.err() << std::endl;
ASSERT_FALSE(cat.err().c_str()[0] == '\0');
}
#endif
TEST(SubProcess, Subshell)
{
SubProcess sh(SHELL, SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE);
sh.add_cmd_args("-c",
"sleep 0; "
"cat; "
"echo 'error from subshell' >&2; "
SHELL " -c 'exit 13'", NULL);
ASSERT_EQ(sh.spawn(), 0);
std::string msg("hello via subshell");
int n = write(sh.get_stdin(), msg.c_str(), msg.size());
ASSERT_EQ(n, (int)msg.size());
sh.close_stdin();
std::string buf;
ASSERT_TRUE(read_from_fd(sh.get_stdout(), buf));
std::cerr << "stdout: " << buf << std::endl;
ASSERT_EQ(buf, msg);
ASSERT_TRUE(read_from_fd(sh.get_stderr(), buf));
std::cerr << "stderr: " << buf;
ASSERT_EQ(buf, "error from subshell\n");
ASSERT_EQ(sh.join(), 13);
std::cerr << "err: " << sh.err() << std::endl;
ASSERT_FALSE(sh.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, True)
{
SubProcessTimed p("true", SubProcess::CLOSE, SubProcess::CLOSE, SubProcess::CLOSE, 10);
ASSERT_EQ(p.spawn(), 0);
ASSERT_EQ(p.join(), 0);
ASSERT_TRUE(p.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, SleepNoTimeout)
{
SubProcessTimed sleep("sleep", SubProcess::CLOSE, SubProcess::CLOSE, SubProcess::CLOSE, 0);
sleep.add_cmd_arg("1");
ASSERT_EQ(sleep.spawn(), 0);
ASSERT_EQ(sleep.join(), 0);
ASSERT_TRUE(sleep.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, Killed)
{
SubProcessTimed cat("cat", SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE, 5);
ASSERT_EQ(cat.spawn(), 0);
cat.kill();
std::string buf;
ASSERT_TRUE(read_from_fd(cat.get_stdout(), buf));
ASSERT_TRUE(buf.empty());
ASSERT_TRUE(read_from_fd(cat.get_stderr(), buf));
ASSERT_TRUE(buf.empty());
ASSERT_EQ(cat.join(), 128 + SIGTERM);
std::cerr << "err: " << cat.err() << std::endl;
ASSERT_FALSE(cat.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, SleepTimedout)
{
SubProcessTimed sleep("sleep", SubProcess::CLOSE, SubProcess::CLOSE, SubProcess::PIPE, 1);
sleep.add_cmd_arg("10");
ASSERT_EQ(sleep.spawn(), 0);
std::string buf;
ASSERT_TRUE(read_from_fd(sleep.get_stderr(), buf));
#ifndef _WIN32
std::cerr << "stderr: " << buf;
ASSERT_FALSE(buf.empty());
#endif
ASSERT_EQ(sleep.join(), 128 + SIGKILL);
std::cerr << "err: " << sleep.err() << std::endl;
ASSERT_FALSE(sleep.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, SubshellNoTimeout)
{
SubProcessTimed sh(SHELL, SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE, 0);
sh.add_cmd_args("-c", "cat >&2", NULL);
ASSERT_EQ(sh.spawn(), 0);
std::string msg("the quick brown fox jumps over the lazy dog");
int n = write(sh.get_stdin(), msg.c_str(), msg.size());
ASSERT_EQ(n, (int)msg.size());
sh.close_stdin();
std::string buf;
ASSERT_TRUE(read_from_fd(sh.get_stdout(), buf));
std::cerr << "stdout: " << buf << std::endl;
ASSERT_TRUE(buf.empty());
ASSERT_TRUE(read_from_fd(sh.get_stderr(), buf));
std::cerr << "stderr: " << buf << std::endl;
ASSERT_EQ(buf, msg);
ASSERT_EQ(sh.join(), 0);
ASSERT_TRUE(sh.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, SubshellKilled)
{
SubProcessTimed sh(SHELL, SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE, 10);
sh.add_cmd_args("-c", SHELL "-c cat", NULL);
ASSERT_EQ(sh.spawn(), 0);
std::string msg("etaoin shrdlu");
int n = write(sh.get_stdin(), msg.c_str(), msg.size());
ASSERT_EQ(n, (int)msg.size());
sh.kill();
std::string buf;
ASSERT_TRUE(read_from_fd(sh.get_stderr(), buf));
ASSERT_TRUE(buf.empty());
ASSERT_EQ(sh.join(), 128 + SIGTERM);
std::cerr << "err: " << sh.err() << std::endl;
ASSERT_FALSE(sh.err().c_str()[0] == '\0');
}
TEST(SubProcessTimed, SubshellTimedout)
{
SubProcessTimed sh(SHELL, SubProcess::PIPE, SubProcess::PIPE, SubProcess::PIPE, 1, SIGTERM);
sh.add_cmd_args("-c", "sleep 1000& cat; NEVER REACHED", NULL);
ASSERT_EQ(sh.spawn(), 0);
std::string buf;
#ifndef _WIN32
ASSERT_TRUE(read_from_fd(sh.get_stderr(), buf));
std::cerr << "stderr: " << buf;
ASSERT_FALSE(buf.empty());
#endif
ASSERT_EQ(sh.join(), 128 + SIGTERM);
std::cerr << "err: " << sh.err() << std::endl;
ASSERT_FALSE(sh.err().c_str()[0] == '\0');
}
#ifndef _WIN32
TEST(fork_function, normal)
{
ASSERT_EQ(0, fork_function(10, std::cerr, [&]() { return 0; }));
ASSERT_EQ(1, fork_function(10, std::cerr, [&]() { return 1; }));
ASSERT_EQ(13, fork_function(10, std::cerr, [&]() { return 13; }));
ASSERT_EQ(-1, fork_function(10, std::cerr, [&]() { return -1; }));
ASSERT_EQ(-13, fork_function(10, std::cerr, [&]() { return -13; }));
ASSERT_EQ(-ETIMEDOUT,
fork_function(10, std::cerr, [&]() { return -ETIMEDOUT; }));
}
TEST(fork_function, timeout)
{
ASSERT_EQ(-ETIMEDOUT, fork_function(2, std::cerr, [&]() {
sleep(60);
return 0; }));
ASSERT_EQ(-ETIMEDOUT, fork_function(2, std::cerr, [&]() {
sleep(60);
return 1; }));
ASSERT_EQ(-ETIMEDOUT, fork_function(2, std::cerr, [&]() {
sleep(60);
return -111; }));
}
#endif
| 9,150 | 28.050794 | 94 |
cc
|
null |
ceph-main/src/test/test_texttable.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2012 Inktank Storage, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/TextTable.h"
#include <iostream>
#include "gtest/gtest.h"
#include "include/coredumpctl.h"
TEST(TextTable, Alignment) {
TextTable t;
// test alignment
// 3 5-character columns
t.define_column("HEAD1", TextTable::LEFT, TextTable::LEFT);
t.define_column("HEAD2", TextTable::LEFT, TextTable::CENTER);
t.define_column("HEAD3", TextTable::LEFT, TextTable::RIGHT);
t << "1" << 2 << 3 << TextTable::endrow;
std::ostringstream oss;
oss << t;
ASSERT_STREQ("HEAD1 HEAD2 HEAD3\n1 2 3\n", oss.str().c_str());
}
TEST(TextTable, WidenAndClearShrink) {
TextTable t;
t.define_column("1", TextTable::LEFT, TextTable::LEFT);
// default column size is 1, widen to 5
t << "wider";
// validate wide output
std::ostringstream oss;
oss << t;
ASSERT_STREQ("1 \nwider\n", oss.str().c_str());
oss.str("");
// reset, validate single-char width output
t.clear();
t << "s";
oss << t;
ASSERT_STREQ("1\ns\n", oss.str().c_str());
}
TEST(TextTable, Indent) {
TextTable t;
t.define_column("1", TextTable::LEFT, TextTable::LEFT);
t.set_indent(10);
t << "s";
std::ostringstream oss;
oss << t;
ASSERT_STREQ(" 1\n s\n", oss.str().c_str());
}
TEST(TextTable, TooManyItems) {
TextTable t;
t.define_column("1", TextTable::LEFT, TextTable::LEFT);
t.define_column("2", TextTable::LEFT, TextTable::LEFT);
t.define_column("3", TextTable::LEFT, TextTable::LEFT);
// expect assertion failure on this, which throws FailedAssertion
PrCtl unset_dumpable;
ASSERT_DEATH((t << "1" << "2" << "3" << "4" << TextTable::endrow), "");
}
| 2,036 | 24.78481 | 80 |
cc
|
null |
ceph-main/src/test/test_trans.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <iostream>
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "os/bluestore/BlueStore.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_filestore
#undef dout_prefix
#define dout_prefix *_dout
using namespace std;
struct Foo : public Thread {
void *entry() override {
dout(0) << "foo started" << dendl;
sleep(1);
dout(0) << "foo asserting 0" << dendl;
ceph_abort();
}
} foo;
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
// args
if (args.size() < 2) return -1;
const char *filename = args[0];
int mb = atoi(args[1]);
cout << "#dev " << filename << std::endl;
cout << "#mb " << mb << std::endl;
ObjectStore *fs = new BlueStore(cct.get(), filename);
if (fs->mount() < 0) {
cout << "mount failed" << std::endl;
return -1;
}
ObjectStore::Transaction t;
char buf[1 << 20];
bufferlist bl;
bl.append(buf, sizeof(buf));
auto ch = fs->create_new_collection(coll_t());
t.create_collection(coll_t(), 0);
for (int i=0; i<mb; i++) {
char f[30];
snprintf(f, sizeof(f), "foo%d\n", i);
sobject_t soid(f, CEPH_NOSNAP);
t.write(coll_t(), ghobject_t(hobject_t(soid)), 0, bl.length(), bl);
}
dout(0) << "starting thread" << dendl;
foo.create("foo");
dout(0) << "starting op" << dendl;
fs->queue_transaction(ch, std::move(t));
}
| 2,052 | 24.345679 | 71 |
cc
|
null |
ceph-main/src/test/test_unfound.sh
|
#!/usr/bin/env bash
set -x
#
# Creates some unfound objects and then tests finding them.
#
# Includes
source "`dirname $0`/test_common.sh"
TEST_POOL=rbd
# Functions
my_write_objects() {
write_objects $1 $2 10 1000000 $TEST_POOL
}
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
# set recovery start to a really long time to ensure that we don't start recovery
./vstart.sh -d -n -o 'osd recovery delay start = 10000
osd max scrubs = 0' || die "vstart failed"
}
osd_resurrection_1_impl() {
# Write lots and lots of objects
my_write_objects 1 2
# Take down osd1
stop_osd 1
# Continue writing a lot of objects
my_write_objects 3 4
# Bring up osd1
restart_osd 1
# Finish peering.
sleep 15
# Stop osd0.
# At this point we have peered, but *NOT* recovered.
# Objects should be lost.
stop_osd 0
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see unfound objects."
echo "Got unfound objects."
(
./rados -c ./ceph.conf -p $TEST_POOL get obj01 $TEMPDIR/obj01 || die "radostool failed"
) &
sleep 5
[ -e $TEMPDIR/obj01 ] && die "unexpected error: fetched unfound object?"
restart_osd 0
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 3 120
[ $? -eq 1 ] || die "Failed to recover unfound objects."
wait
[ -e $TEMPDIR/obj01 ] || die "unexpected error: failed to fetched newly-found object"
# Turn off recovery delay start and verify that every osd gets copies
# of the correct objects.
echo "starting recovery..."
start_recovery 2
# success
return 0
}
osd_resurrection_1() {
setup 2
osd_resurrection_1_impl
}
stray_test_impl() {
stop_osd 0
# 0:stopped 1:active 2:active
my_write_objects 1 1
stop_osd 1
sleep 15
# 0:stopped 1:stopped(ver1) 2:active(ver1)
my_write_objects 2 2
restart_osd 1
sleep 15
# 0:stopped 1:active(ver1) 2:active(ver2)
stop_osd 2
sleep 15
# 0:stopped 1:active(ver1) 2:stopped(ver2)
restart_osd 0
sleep 15
# 0:active 1:active(ver1) 2:stopped(ver2)
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 5 300
[ $? -eq 1 ] || die "Failed to see unfound objects."
#
# Now, when we bring up osd2, it will be considered a stray. However, it
# has the version that we need-- the very latest version of the
# objects.
#
restart_osd 2
sleep 15
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 4 240
[ $? -eq 1 ] || die "Failed to discover unfound objects."
echo "starting recovery..."
start_recovery 3
# success
return 0
}
stray_test() {
setup 3
stray_test_impl
}
run() {
osd_resurrection_1 || die "test failed"
stray_test || die "test failed"
}
$@
| 3,137 | 21.414286 | 103 |
sh
|
null |
ceph-main/src/test/test_utime.cc
|
#include "include/utime.h"
#include "gtest/gtest.h"
#include "include/stringify.h"
#include "common/ceph_context.h"
using namespace std;
TEST(utime_t, localtime)
{
utime_t t(1556122013, 839991182);
string s = stringify(t);
cout << s << std::endl;
// time zone may vary where unit test is run, so be cirsumspect...
ASSERT_EQ(s.size(), strlen("2019-04-24T11:06:53.839991-0500"));
ASSERT_TRUE(s[26] == '-' || s[26] == '+');
ASSERT_EQ(s.substr(0, 9), "2019-04-2");
}
TEST(utime_t, gmtime)
{
utime_t t(1556122013, 39991182);
{
ostringstream ss;
t.gmtime(ss);
ASSERT_EQ(ss.str(), "2019-04-24T16:06:53.039991Z");
}
{
ostringstream ss;
t.gmtime_nsec(ss);
ASSERT_EQ(ss.str(), "2019-04-24T16:06:53.039991182Z");
}
}
TEST(utime_t, asctime)
{
utime_t t(1556122013, 839991182);
ostringstream ss;
t.asctime(ss);
string s = ss.str();
ASSERT_EQ(s, "Wed Apr 24 16:06:53 2019");
}
const char *v[][2] = {
{ "2019-04-24T16:06:53.039991Z", "2019-04-24T16:06:53.039991Z" },
{ "2019-04-24 16:06:53.039991Z", "2019-04-24T16:06:53.039991Z" },
{ "2019-04-24 16:06:53.039991+0000", "2019-04-24T16:06:53.039991Z" },
{ "2019-04-24 16:06:53.039991-0100", "2019-04-24T17:06:53.039991Z" },
{ "2019-04-24 16:06:53.039991+0430", "2019-04-24T11:36:53.039991Z" },
{ "2019-04-24 16:06:53+0000", "2019-04-24T16:06:53.000000Z" },
{ "2019-04-24T16:06:53-0100", "2019-04-24T17:06:53.000000Z" },
{ "2019-04-24 16:06:53+0430", "2019-04-24T11:36:53.000000Z" },
{ "2019-04-24", "2019-04-24T00:00:00.000000Z" },
{ 0, 0 },
};
TEST(utime_t, parse_date)
{
for (unsigned i = 0; v[i][0]; ++i) {
cout << v[i][0] << " -> " << v[i][1] << std::endl;
utime_t t;
bool r = t.parse(string(v[i][0]));
ASSERT_TRUE(r);
ostringstream ss;
t.gmtime(ss);
ASSERT_EQ(ss.str(), v[i][1]);
}
}
| 1,839 | 26.058824 | 71 |
cc
|
null |
ceph-main/src/test/test_weighted_shuffle.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/weighted_shuffle.h"
#include <array>
#include <map>
#include "gtest/gtest.h"
TEST(WeightedShuffle, Basic) {
std::array<char, 5> choices{'a', 'b', 'c', 'd', 'e'};
std::array<int, 5> weights{100, 50, 25, 10, 1};
std::map<char, std::array<unsigned, 5>> frequency {
{'a', {0, 0, 0, 0, 0}},
{'b', {0, 0, 0, 0, 0}},
{'c', {0, 0, 0, 0, 0}},
{'d', {0, 0, 0, 0, 0}},
{'e', {0, 0, 0, 0, 0}}
}; // count each element appearing in each position
const int samples = 10000;
std::random_device rd;
for (auto i = 0; i < samples; i++) {
weighted_shuffle(begin(choices), end(choices),
begin(weights), end(weights),
std::mt19937{rd()});
for (size_t j = 0; j < choices.size(); ++j)
++frequency[choices[j]][j];
}
// verify that the probability that the nth choice is selected as the first
// one is the nth weight divided by the sum of all weights
const auto total_weight = std::accumulate(weights.begin(), weights.end(), 0);
constexpr float epsilon = 0.02;
for (unsigned i = 0; i < choices.size(); i++) {
const auto& f = frequency[choices[i]];
const auto& w = weights[i];
ASSERT_NEAR(float(w) / total_weight,
float(f.front()) / samples,
epsilon);
}
}
| 1,340 | 32.525 | 79 |
cc
|
null |
ceph-main/src/test/test_workqueue.cc
|
#include "gtest/gtest.h"
#include "common/WorkQueue.h"
#include "common/ceph_argparse.h"
using namespace std;
TEST(WorkQueue, StartStop)
{
ThreadPool tp(g_ceph_context, "foo", "tp_foo", 10, "");
tp.start();
tp.pause();
tp.pause_new();
tp.unpause();
tp.unpause();
tp.drain();
tp.stop();
}
TEST(WorkQueue, Resize)
{
ThreadPool tp(g_ceph_context, "bar", "tp_bar", 2, "filestore_op_threads");
tp.start();
sleep(1);
ASSERT_EQ(2, tp.get_num_threads());
g_conf().set_val("filestore op threads", "5");
g_conf().apply_changes(&cout);
sleep(1);
ASSERT_EQ(5, tp.get_num_threads());
g_conf().set_val("filestore op threads", "3");
g_conf().apply_changes(&cout);
sleep(1);
ASSERT_EQ(3, tp.get_num_threads());
g_conf().set_val("filestore op threads", "0");
g_conf().apply_changes(&cout);
sleep(1);
ASSERT_EQ(0, tp.get_num_threads());
g_conf().set_val("filestore op threads", "15");
g_conf().apply_changes(&cout);
sleep(1);
ASSERT_EQ(15, tp.get_num_threads());
g_conf().set_val("filestore op threads", "-1");
g_conf().apply_changes(&cout);
sleep(1);
ASSERT_EQ(15, tp.get_num_threads());
sleep(1);
tp.stop();
}
class twq : public ThreadPool::WorkQueue<int> {
public:
twq(time_t timeout, time_t suicide_timeout, ThreadPool *tp)
: ThreadPool::WorkQueue<int>("test_wq", ceph::make_timespan(timeout), ceph::make_timespan(suicide_timeout), tp) {}
bool _enqueue(int* item) override {
return true;
}
void _dequeue(int* item) override {
ceph_abort();
}
bool _empty() override {
return true;
}
int *_dequeue() override {
return nullptr;
}
void _process(int *osr, ThreadPool::TPHandle &handle) override {
}
void _process_finish(int *osr) override {
}
void _clear() override {
}
};
TEST(WorkQueue, change_timeout){
ThreadPool tp(g_ceph_context, "bar", "tp_bar", 2, "filestore_op_threads");
tp.start();
twq wq(2, 20, &tp);
// check timeout and suicide
ASSERT_EQ(ceph::make_timespan(2), wq.timeout_interval.load());
ASSERT_EQ(ceph::make_timespan(20), wq.suicide_interval.load());
// change the timeout and suicide and then check them
wq.set_timeout(4);
wq.set_suicide_timeout(40);
ASSERT_EQ(ceph::make_timespan(4), wq.timeout_interval.load());
ASSERT_EQ(ceph::make_timespan(40), wq.suicide_interval.load());
tp.stop();
}
| 2,428 | 23.535354 | 122 |
cc
|
null |
ceph-main/src/test/test_xlist.cc
|
#include <algorithm>
#include <iterator>
#include <vector>
#include "include/xlist.h"
#include "gtest/gtest.h"
struct Item {
xlist<Item*>::item xitem;
int val;
explicit Item(int v) :
xitem(this),
val(v)
{}
};
class XlistTest : public testing::Test
{
protected:
typedef xlist<Item*> ItemList;
typedef std::vector<Item*> Items;
typedef std::vector<ItemList::item*> Refs;
Items items;
// for filling up an ItemList
Refs refs;
void SetUp() override {
for (int i = 0; i < 13; i++) {
items.push_back(new Item(i));
refs.push_back(&items.back()->xitem);
}
}
void TearDown() override {
for (Items::iterator i = items.begin(); i != items.end(); ++i) {
delete *i;
}
items.clear();
}
};
TEST_F(XlistTest, capability) {
ItemList list;
ASSERT_TRUE(list.empty());
ASSERT_EQ(0u, list.size());
std::copy(refs.begin(), refs.end(), std::back_inserter(list));
ASSERT_EQ((size_t)list.size(), refs.size());
list.clear();
ASSERT_TRUE(list.empty());
ASSERT_EQ(0u, list.size());
}
TEST_F(XlistTest, traverse) {
ItemList list;
std::copy(refs.begin(), refs.end(), std::back_inserter(list));
// advance until iterator::end()
size_t index = 0;
for (ItemList::iterator i = list.begin(); !i.end(); ++i) {
ASSERT_EQ(*i, items[index]);
index++;
}
// advance until i == v.end()
index = 0;
for (ItemList::iterator i = list.begin(); i != list.end(); ++i) {
ASSERT_EQ(*i, items[index]);
index++;
}
list.clear();
}
TEST_F(XlistTest, move_around) {
Item item1(42), item2(17);
ItemList list;
// only a single element in the list
list.push_back(&item1.xitem);
ASSERT_EQ(&item1, list.front());
ASSERT_EQ(&item1, list.back());
list.push_back(&item2.xitem);
ASSERT_EQ(&item1, list.front());
ASSERT_EQ(&item2, list.back());
// move item2 to the front
list.push_front(&item2.xitem);
ASSERT_EQ(&item2, list.front());
ASSERT_EQ(&item1, list.back());
// and move it back
list.push_back(&item2.xitem);
ASSERT_EQ(&item1, list.front());
ASSERT_EQ(&item2, list.back());
list.clear();
}
TEST_F(XlistTest, item_queries) {
Item item(42);
ItemList list;
list.push_back(&item.xitem);
ASSERT_TRUE(item.xitem.is_on_list());
ASSERT_EQ(&list, item.xitem.get_list());
ASSERT_TRUE(item.xitem.remove_myself());
ASSERT_FALSE(item.xitem.is_on_list());
ASSERT_TRUE(item.xitem.get_list() == NULL);
}
// Local Variables:
// compile-command: "cd .. ;
// make unittest_xlist &&
// ./unittest_xlist"
// End:
| 2,540 | 20.352941 | 68 |
cc
|
null |
ceph-main/src/test/testclass.cc
|
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include "objclass/objclass.h"
CLS_VER(1,0)
CLS_NAME(test)
cls_handle_t h_class;
cls_method_handle_t h_foo;
int foo_method(cls_method_context_t ctx, char *indata, int datalen,
char **outdata, int *outdatalen)
{
int i, r;
cls_log("hello world");
cls_log("indata=%s", indata);
*outdata = (char *)cls_alloc(128);
for (i=0; i<strlen(indata) + 1; i++) {
if (indata[i] == '0') {
(*outdata)[i] = '*';
} else {
(*outdata)[i] = indata[i];
}
}
*outdatalen = strlen(*outdata) + 1;
cls_log("outdata=%s", *outdata);
r = cls_call(ctx, "foo", "foo", *outdata, *outdatalen, outdata, outdatalen);
return r;
}
static cls_deps_t depend[] = {{"foo", "1.0"}, {"bar", "1.0"}, {NULL, NULL}};
extern "C" cls_deps_t *class_deps()
{
return depend;
};
void class_init()
{
cls_log("Loaded class test!");
cls_register("test", &h_class);
cls_register_method(h_class, "foo", foo_method, &h_foo);
return;
}
| 1,032 | 16.810345 | 79 |
cc
|
null |
ceph-main/src/test/testcrypto.cc
|
#include "auth/Crypto.h"
#include "common/Clock.h"
#include "common/config.h"
#include "common/debug.h"
#define dout_subsys ceph_subsys_auth
#define AES_KEY_LEN 16
#define dout_context g_ceph_context
using namespace std;
int main(int argc, char *argv[])
{
char aes_key[AES_KEY_LEN];
memset(aes_key, 0x77, sizeof(aes_key));
bufferptr keybuf(aes_key, sizeof(aes_key));
CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(), keybuf);
const char *msg="hello! this is a message\n";
char pad[16];
memset(pad, 0, 16);
bufferptr ptr(msg, strlen(msg));
bufferlist enc_in;
enc_in.append(ptr);
enc_in.append(msg, strlen(msg));
bufferlist enc_out;
std::string error;
if (key.encrypt(g_ceph_context, enc_in, enc_out, &error) < 0) {
ceph_assert(!error.empty());
dout(0) << "couldn't encode! error " << error << dendl;
exit(1);
}
const char *enc_buf = enc_out.c_str();
for (unsigned i=0; i<enc_out.length(); i++) {
std::cout << hex << (int)(unsigned char)enc_buf[i] << dec << " ";
if (i && !(i%16))
std::cout << std::endl;
}
bufferlist dec_in, dec_out;
dec_in = enc_out;
if (key.decrypt(g_ceph_context, dec_in, dec_out, &error) < 0) {
ceph_assert(!error.empty());
dout(0) << "couldn't decode! error " << error << dendl;
exit(1);
}
dout(0) << "decoded len: " << dec_out.length() << dendl;
dout(0) << "decoded msg: " << dec_out.c_str() << dendl;
return 0;
}
| 1,438 | 22.590164 | 69 |
cc
|
null |
ceph-main/src/test/testkeys.cc
|
#include "auth/cephx/CephxKeyServer.h"
#include "common/ceph_argparse.h"
#include "global/global_init.h"
#include "common/config.h"
#include "common/debug.h"
#define dout_context g_ceph_context
#define AES_KEY_LEN 16
using namespace std;
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
KeyRing extra;
KeyServer server(g_ceph_context, &extra);
generic_dout(0) << "server created" << dendl;
getchar();
#if 0
char aes_key[AES_KEY_LEN];
memset(aes_key, 0x77, sizeof(aes_key));
bufferptr keybuf(aes_key, sizeof(aes_key));
CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(), keybuf);
const char *msg="hello! this is a message\n";
char pad[16];
memset(pad, 0, 16);
bufferptr ptr(msg, strlen(msg));
bufferlist enc_in;
enc_in.append(ptr);
enc_in.append(msg, strlen(msg));
bufferlist enc_out;
if (key.encrypt(enc_in, enc_out) < 0) {
derr(0) << "couldn't encode!" << dendl;
exit(1);
}
const char *enc_buf = enc_out.c_str();
for (unsigned i=0; i<enc_out.length(); i++) {
std::cout << hex << (int)(unsigned char)enc_buf[i] << dec << " ";
if (i && !(i%16))
std::cout << std::endl;
}
bufferlist dec_in, dec_out;
dec_in = enc_out;
if (key.decrypt(dec_in, dec_out) < 0) {
derr(0) << "couldn't decode!" << dendl;
}
dout(0) << "decoded len: " << dec_out.length() << dendl;
dout(0) << "decoded msg: " << dec_out.c_str() << dendl;
return 0;
#endif
}
| 1,647 | 22.542857 | 69 |
cc
|
null |
ceph-main/src/test/testmsgr.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <sys/stat.h>
#include <iostream>
#include <string>
using namespace std;
#include "common/config.h"
#include "mon/MonMap.h"
#include "mon/MonClient.h"
#include "msg/Messenger.h"
#include "messages/MPing.h"
#include "common/Timer.h"
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include <sys/types.h>
#include <fcntl.h>
#define dout_subsys ceph_subsys_ms
Messenger *messenger = 0;
ceph::mutex test_lock = ceph::make_mutex("mylock");
ceph::condition_variable cond;
uint64_t received = 0;
class Admin : public Dispatcher {
public:
Admin()
: Dispatcher(g_ceph_context)
{
}
private:
bool ms_dispatch(Message *m) {
//cerr << "got ping from " << m->get_source() << std::endl;
dout(0) << "got ping from " << m->get_source() << dendl;
test_lock.lock();
++received;
cond.notify_all();
test_lock.unlock();
m->put();
return true;
}
bool ms_handle_reset(Connection *con) { return false; }
void ms_handle_remote_reset(Connection *con) {}
bool ms_handle_refused(Connection *con) { return false; }
} dispatcher;
int main(int argc, const char **argv, const char *envp[]) {
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
dout(0) << "i am mon " << args[0] << dendl;
// get monmap
MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
// start up network
int whoami = mc.monmap.get_rank(args[0]);
ceph_assert(whoami >= 0);
ostringstream ss;
ss << mc.monmap.get_addr(whoami);
std::string sss(ss.str());
g_ceph_context->_conf.set_val("public_addr", sss.c_str());
g_ceph_context->_conf.apply_changes(nullptr);
std::string public_msgr_type = g_conf()->ms_public_type.empty() ? g_conf().get_val<std::string>("ms_type") : g_conf()->ms_public_type;
Messenger *rank = Messenger::create(g_ceph_context,
public_msgr_type,
entity_name_t::MON(whoami), "tester",
getpid());
int err = rank->bind(g_ceph_context->_conf->public_addr);
if (err < 0)
return 1;
// start monitor
messenger = rank;
messenger->set_default_send_priority(CEPH_MSG_PRIO_HIGH);
messenger->add_dispatcher_head(&dispatcher);
rank->start();
int isend = 0;
if (whoami == 0)
isend = 100;
std::unique_lock l{test_lock};
uint64_t sent = 0;
while (1) {
while (received + isend <= sent) {
//cerr << "wait r " << received << " s " << sent << " is " << isend << std::endl;
dout(0) << "wait r " << received << " s " << sent << " is " << isend << dendl;
cond.wait(l);
}
int t = rand() % mc.get_num_mon();
if (t == whoami)
continue;
if (rand() % 10 == 0) {
//cerr << "mark_down " << t << std::endl;
dout(0) << "mark_down " << t << dendl;
messenger->mark_down_addrs(mc.get_mon_addrs(t));
}
//cerr << "pinging " << t << std::endl;
dout(0) << "pinging " << t << dendl;
messenger->send_to_mon(new MPing, mc.get_mon_addrs(t));
cerr << isend << "\t" << ++sent << "\t" << received << "\r";
}
l.unlock();
// wait for messenger to finish
rank->wait();
return 0;
}
| 3,699 | 24.517241 | 136 |
cc
|
null |
ceph-main/src/test/unit.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_UNIT_TEST_H
#define CEPH_UNIT_TEST_H
#include "include/types.h" // FIXME: ordering shouldn't be important, but right
// now, this include has to come before the others.
#include "common/ceph_argparse.h"
#include "common/code_environment.h"
#include "common/config.h"
#include "global/global_context.h"
#include "global/global_init.h"
#include "include/msgr.h" // for CEPH_ENTITY_TYPE_CLIENT
#include "gtest/gtest.h"
#include <vector>
/*
* You only need to include this file if you are testing Ceph internal code. If
* you are testing library code, the library init() interfaces will handle
* initialization for you.
*/
int main(int argc, char **argv) {
std::vector<const char*> args(argv, argv + argc);
auto cct = global_init(NULL, args,
CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_MON_CONFIG);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
#endif
| 1,407 | 27.734694 | 80 |
cc
|
null |
ceph-main/src/test/utf8.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/utf8.h"
#include "gtest/gtest.h"
#include <stdint.h>
TEST(IsValidUtf8, SimpleAscii) {
ASSERT_EQ(0, check_utf8_cstr("Ascii ftw."));
ASSERT_EQ(0, check_utf8_cstr(""));
ASSERT_EQ(0, check_utf8_cstr("B"));
ASSERT_EQ(0, check_utf8_cstr("Badgers badgers badgers badgers "
"mushroom mushroom"));
ASSERT_EQ(0, check_utf8("foo", strlen("foo")));
}
TEST(IsValidUtf8, ControlChars) {
// Sadly, control characters are valid utf8...
uint8_t control_chars[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d };
ASSERT_EQ(0, check_utf8((char*)control_chars, sizeof(control_chars)));
}
TEST(IsValidUtf8, SimpleUtf8) {
uint8_t funkystr[] = { 0x66, 0xd1, 0x86, 0xd1, 0x9d, 0xd2, 0xa0, 0xd3,
0xad, 0xd3, 0xae, 0x0a };
ASSERT_EQ(0, check_utf8((char*)funkystr, sizeof(funkystr)));
uint8_t valid2[] = { 0xc3, 0xb1 };
ASSERT_EQ(0, check_utf8((char*)valid2, sizeof(valid2)));
}
TEST(IsValidUtf8, InvalidUtf8) {
uint8_t inval[] = { 0xe2, 0x28, 0xa1 };
ASSERT_NE(0, check_utf8((char*)inval, sizeof(inval)));
uint8_t invalid2[] = { 0xc3, 0x28 };
ASSERT_NE(0, check_utf8((char*)invalid2, sizeof(invalid2)));
}
TEST(HasControlChars, HasControlChars1) {
uint8_t has_control_chars[] = { 0x41, 0x01, 0x00 };
ASSERT_NE(0, check_for_control_characters_cstr((const char*)has_control_chars));
uint8_t has_control_chars2[] = { 0x7f, 0x41, 0x00 };
ASSERT_NE(0, check_for_control_characters_cstr((const char*)has_control_chars2));
char has_newline[] = "blah blah\n";
ASSERT_NE(0, check_for_control_characters_cstr(has_newline));
char no_control_chars[] = "blah blah";
ASSERT_EQ(0, check_for_control_characters_cstr(no_control_chars));
uint8_t validutf[] = { 0x66, 0xd1, 0x86, 0xd1, 0x9d, 0xd2, 0xa0, 0xd3,
0xad, 0xd3, 0xae, 0x0 };
ASSERT_EQ(0, check_for_control_characters_cstr((const char*)validutf));
}
| 2,326 | 33.731343 | 83 |
cc
|
null |
ceph-main/src/test/vstart_wrapper.sh
|
#!/usr/bin/env bash
#
# Copyright (C) 2013 Cloudwatt <[email protected]>
# Copyright (C) 2015 Red Hat <[email protected]>
#
# Author: Loic Dachary <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Library Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library Public License for more details.
#
source $CEPH_ROOT/qa/standalone/ceph-helpers.sh
export CEPH_VSTART_WRAPPER=1
export CEPH_DIR="${TMPDIR:-$PWD}/td/t-$CEPH_PORT"
export CEPH_DEV_DIR="$CEPH_DIR/dev"
export CEPH_OUT_DIR="$CEPH_DIR/out"
export CEPH_ASOK_DIR="$CEPH_DIR/out"
export MGR_PYTHON_PATH=$CEPH_ROOT/src/pybind/mgr
function vstart_setup()
{
rm -fr $CEPH_DEV_DIR $CEPH_OUT_DIR
mkdir -p $CEPH_DEV_DIR
trap "teardown $CEPH_DIR" EXIT
export LC_ALL=C # some tests are vulnerable to i18n
export PATH="$(pwd):${PATH}"
OBJSTORE_ARGS=""
if [ "bluestore" = "${CEPH_OBJECTSTORE}" ]; then
OBJSTORE_ARGS="-b"
fi
$CEPH_ROOT/src/vstart.sh \
--short \
$OBJSTORE_ARGS \
-o 'paxos propose interval = 0.01' \
-d -n -l || return 1
export CEPH_CONF=$CEPH_DIR/ceph.conf
crit=$(expr 100 - $(ceph-conf --show-config-value mon_data_avail_crit))
if [ $(df . | perl -ne 'print if(s/.*\s(\d+)%.*/\1/)') -ge $crit ] ; then
df .
cat <<EOF
error: not enough free disk space for mon to run
The mon will shutdown with a message such as
"reached critical levels of available space on local monitor storage -- shutdown!"
as soon as it finds the disk has is more than ${crit}% full.
This is a limit determined by
ceph-conf --show-config-value mon_data_avail_crit
EOF
return 1
fi
}
function main()
{
teardown $CEPH_DIR
vstart_setup || return 1
if CEPH_CONF=$CEPH_DIR/ceph.conf "$@"; then
code=0
else
code=1
display_logs $CEPH_OUT_DIR
fi
return $code
}
main "$@"
| 2,231 | 28.368421 | 83 |
sh
|
null |
ceph-main/src/test/xattr_bench.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <iostream>
#include <iterator>
#include <sstream>
#include "os/bluestore/BlueStore.h"
#include "include/Context.h"
#include "common/ceph_argparse.h"
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "global/global_init.h"
#include <boost/scoped_ptr.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/binomial_distribution.hpp>
#include <gtest/gtest.h>
#include "include/unordered_map.h"
void usage(const string &name) {
std::cerr << "Usage: " << name << " [xattr|omap] store_path"
<< std::endl;
}
const int THREADS = 5;
template <typename T>
typename T::iterator rand_choose(T &cont) {
if (std::empty(cont) == 0) {
return std::end(cont);
}
return std::next(std::begin(cont), rand() % cont.size());
}
class OnApplied : public Context {
public:
ceph::mutex *lock;
ceph::condition_variable *cond;
int *in_progress;
ObjectStore::Transaction *t;
OnApplied(ceph::mutex *lock,
ceph::condition_variable *cond,
int *in_progress,
ObjectStore::Transaction *t)
: lock(lock), cond(cond),
in_progress(in_progress), t(t) {
std::lock_guard l{*lock};
(*in_progress)++;
}
void finish(int r) override {
std::lock_guard l{*lock};
(*in_progress)--;
cond->notify_all();
}
};
uint64_t get_time() {
time_t start;
time(&start);
return start * 1000;
}
double print_time(uint64_t ms) {
return ((double)ms)/1000;
}
uint64_t do_run(ObjectStore *store, int attrsize, int numattrs,
int run,
int transsize, int ops,
ostream &out) {
ceph::mutex lock = ceph::make_mutex("lock");
ceph::condition_variable cond;
int in_flight = 0;
ObjectStore::Sequencer osr(__func__);
ObjectStore::Transaction t;
map<coll_t, pair<set<string>, ObjectStore::Sequencer*> > collections;
for (int i = 0; i < 3*THREADS; ++i) {
coll_t coll(spg_t(pg_t(0, i + 1000*run), shard_id_t::NO_SHARD));
t.create_collection(coll, 0);
set<string> objects;
for (int i = 0; i < transsize; ++i) {
stringstream obj_str;
obj_str << i;
t.touch(coll,
ghobject_t(hobject_t(sobject_t(obj_str.str(), CEPH_NOSNAP))));
objects.insert(obj_str.str());
}
collections[coll] = make_pair(objects, new ObjectStore::Sequencer(coll.to_str()));
}
store->queue_transaction(&osr, std::move(t));
bufferlist bl;
for (int i = 0; i < attrsize; ++i) {
bl.append('\0');
}
uint64_t start = get_time();
for (int i = 0; i < ops; ++i) {
{
std::unique_lock l{lock};
cond.wait(l, [&] { in_flight < THREADS; });
}
ObjectStore::Transaction *t = new ObjectStore::Transaction;
map<coll_t, pair<set<string>, ObjectStore::Sequencer*> >::iterator iter =
rand_choose(collections);
for (set<string>::iterator obj = iter->second.first.begin();
obj != iter->second.first.end();
++obj) {
for (int j = 0; j < numattrs; ++j) {
stringstream ss;
ss << i << ", " << j << ", " << *obj;
t->setattr(iter->first,
ghobject_t(hobject_t(sobject_t(*obj, CEPH_NOSNAP))),
ss.str().c_str(),
bl);
}
}
store->queue_transaction(iter->second.second, std::move(*t),
new OnApplied(&lock, &cond, &in_flight,
t));
delete t;
}
{
std::unique_lock l{lock};
cond.wait(l, [&] { return in_flight == 0; });
}
return get_time() - start;
}
int main(int argc, char **argv) {
auto args = argv_to_vec(argc, argv);
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage(argv[0]);
exit(0);
}
auto cct = global_init(0, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
std::cerr << "args: " << args << std::endl;
if (args.size() < 2) {
usage(argv[0]);
return 1;
}
string store_path(args[1]);
boost::scoped_ptr<ObjectStore> store(new BlueStore(cct.get(), store_path));
std::cerr << "mkfs starting" << std::endl;
ceph_assert(!store->mkfs());
ceph_assert(!store->mount());
std::cerr << "mounted" << std::endl;
std::cerr << "attrsize\tnumattrs\ttranssize\tops\ttime" << std::endl;
int runs = 0;
int total_size = 11;
for (int i = 6; i < total_size; ++i) {
for (int j = (total_size - i); j >= 0; --j) {
std::cerr << "starting run " << runs << std::endl;
++runs;
uint64_t time = do_run(store.get(), (1 << i), (1 << j), runs,
10,
1000, std::cout);
std::cout << (1 << i) << "\t"
<< (1 << j) << "\t"
<< 10 << "\t"
<< 1000 << "\t"
<< print_time(time) << std::endl;
}
}
store->umount();
return 0;
}
| 5,204 | 25.42132 | 86 |
cc
|
null |
ceph-main/src/test/ObjectMap/KeyValueDBMemory.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/encoding.h"
#include "KeyValueDBMemory.h"
#include <map>
#include <set>
#include <iostream>
using namespace std;
/**
* Iterate over the whole key space of the in-memory store
*
* @note Removing keys from the store while iterating over the store key-space
* may result in unspecified behavior.
* If one wants to safely iterate over the store while updating the
* store, one should instead use a snapshot iterator, which provides
* strong read-consistency.
*/
class WholeSpaceMemIterator : public KeyValueDB::WholeSpaceIteratorImpl {
protected:
KeyValueDBMemory *db;
bool ready;
map<pair<string,string>, bufferlist>::iterator it;
public:
explicit WholeSpaceMemIterator(KeyValueDBMemory *db) : db(db), ready(false) { }
~WholeSpaceMemIterator() override { }
int seek_to_first() override {
if (db->db.empty()) {
it = db->db.end();
ready = false;
return 0;
}
it = db->db.begin();
ready = true;
return 0;
}
int seek_to_first(const string &prefix) override {
it = db->db.lower_bound(make_pair(prefix, ""));
if (db->db.empty() || (it == db->db.end())) {
it = db->db.end();
ready = false;
return 0;
}
ready = true;
return 0;
}
int seek_to_last() override {
it = db->db.end();
if (db->db.empty()) {
ready = false;
return 0;
}
--it;
ceph_assert(it != db->db.end());
ready = true;
return 0;
}
int seek_to_last(const string &prefix) override {
string tmp(prefix);
tmp.append(1, (char) 0);
it = db->db.upper_bound(make_pair(tmp,""));
if (db->db.empty() || (it == db->db.end())) {
seek_to_last();
}
else {
ready = true;
prev();
}
return 0;
}
int lower_bound(const string &prefix, const string &to) override {
it = db->db.lower_bound(make_pair(prefix,to));
if ((db->db.empty()) || (it == db->db.end())) {
it = db->db.end();
ready = false;
return 0;
}
ceph_assert(it != db->db.end());
ready = true;
return 0;
}
int upper_bound(const string &prefix, const string &after) override {
it = db->db.upper_bound(make_pair(prefix,after));
if ((db->db.empty()) || (it == db->db.end())) {
it = db->db.end();
ready = false;
return 0;
}
ceph_assert(it != db->db.end());
ready = true;
return 0;
}
bool valid() override {
return ready && (it != db->db.end());
}
bool begin() {
return ready && (it == db->db.begin());
}
int prev() override {
if (!begin() && ready)
--it;
else
it = db->db.end();
return 0;
}
int next() override {
if (valid())
++it;
return 0;
}
string key() override {
if (valid())
return (*it).first.second;
else
return "";
}
pair<string,string> raw_key() override {
if (valid())
return (*it).first;
else
return make_pair("", "");
}
bool raw_key_is_prefixed(const string &prefix) override {
return prefix == (*it).first.first;
}
bufferlist value() override {
if (valid())
return (*it).second;
else
return bufferlist();
}
int status() override {
return 0;
}
};
int KeyValueDBMemory::get(const string &prefix,
const std::set<string> &key,
map<string, bufferlist> *out) {
if (!exists_prefix(prefix))
return 0;
for (std::set<string>::const_iterator i = key.begin();
i != key.end();
++i) {
pair<string,string> k(prefix, *i);
if (db.count(k))
(*out)[*i] = db[k];
}
return 0;
}
int KeyValueDBMemory::get_keys(const string &prefix,
const std::set<string> &key,
std::set<string> *out) {
if (!exists_prefix(prefix))
return 0;
for (std::set<string>::const_iterator i = key.begin();
i != key.end();
++i) {
if (db.count(make_pair(prefix, *i)))
out->insert(*i);
}
return 0;
}
int KeyValueDBMemory::set(const string &prefix,
const string &key,
const bufferlist &bl) {
db[make_pair(prefix,key)] = bl;
return 0;
}
int KeyValueDBMemory::rmkey(const string &prefix,
const string &key) {
db.erase(make_pair(prefix,key));
return 0;
}
int KeyValueDBMemory::rmkeys_by_prefix(const string &prefix) {
map<std::pair<string,string>,bufferlist>::iterator i;
i = db.lower_bound(make_pair(prefix, ""));
if (i == db.end())
return 0;
while (i != db.end()) {
std::pair<string,string> key = (*i).first;
if (key.first != prefix)
break;
++i;
rmkey(key.first, key.second);
}
return 0;
}
int KeyValueDBMemory::rm_range_keys(const string &prefix, const string &start, const string &end) {
map<std::pair<string,string>,bufferlist>::iterator i;
i = db.lower_bound(make_pair(prefix, start));
if (i == db.end())
return 0;
while (i != db.end()) {
std::pair<string,string> key = (*i).first;
if (key.first != prefix)
break;
if (key.second >= end)
break;
++i;
rmkey(key.first, key.second);
}
return 0;
}
KeyValueDB::WholeSpaceIterator KeyValueDBMemory::get_wholespace_iterator(IteratorOpts opts) {
return std::shared_ptr<KeyValueDB::WholeSpaceIteratorImpl>(
new WholeSpaceMemIterator(this)
);
}
class WholeSpaceSnapshotMemIterator : public WholeSpaceMemIterator {
public:
/**
* @note
* We perform a copy of the db map, which is populated by bufferlists.
*
* These are designed as shallow containers, thus there is a chance that
* changing the underlying memory pages will lead to the iterator seeing
* erroneous states.
*
* Although we haven't verified this yet, there is this chance, so we should
* keep it in mind.
*/
explicit WholeSpaceSnapshotMemIterator(KeyValueDBMemory *db) :
WholeSpaceMemIterator(db) { }
~WholeSpaceSnapshotMemIterator() override {
delete db;
}
};
| 5,982 | 21.577358 | 99 |
cc
|
null |
ceph-main/src/test/ObjectMap/KeyValueDBMemory.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <map>
#include <set>
#include <string>
#include "kv/KeyValueDB.h"
#include "include/buffer.h"
#include "include/Context.h"
using std::string;
class KeyValueDBMemory : public KeyValueDB {
public:
std::map<std::pair<string,string>,bufferlist> db;
KeyValueDBMemory() { }
explicit KeyValueDBMemory(KeyValueDBMemory *db) : db(db->db) { }
~KeyValueDBMemory() override { }
int init(string _opt) override {
return 0;
}
int open(std::ostream &out, const std::string& cfs="") override {
return 0;
}
int create_and_open(std::ostream &out, const std::string& cfs="") override {
return 0;
}
int get(
const std::string &prefix,
const std::set<std::string> &key,
std::map<std::string, bufferlist> *out
) override;
using KeyValueDB::get;
int get_keys(
const std::string &prefix,
const std::set<std::string> &key,
std::set<std::string> *out
);
int set(
const std::string &prefix,
const std::string &key,
const bufferlist &bl
);
int rmkey(
const std::string &prefix,
const std::string &key
);
int rmkeys_by_prefix(
const std::string &prefix
);
int rm_range_keys(
const std::string &prefix,
const std::string &start,
const std::string &end
);
class TransactionImpl_ : public TransactionImpl {
public:
std::list<Context *> on_commit;
KeyValueDBMemory *db;
explicit TransactionImpl_(KeyValueDBMemory *db) : db(db) {}
struct SetOp : public Context {
KeyValueDBMemory *db;
std::pair<std::string,std::string> key;
bufferlist value;
SetOp(KeyValueDBMemory *db,
const std::pair<std::string,std::string> &key,
const bufferlist &value)
: db(db), key(key), value(value) {}
void finish(int r) override {
db->set(key.first, key.second, value);
}
};
void set(const std::string &prefix, const std::string &k, const bufferlist& bl) override {
on_commit.push_back(new SetOp(db, std::make_pair(prefix, k), bl));
}
struct RmKeysOp : public Context {
KeyValueDBMemory *db;
std::pair<std::string,std::string> key;
RmKeysOp(KeyValueDBMemory *db,
const std::pair<std::string,std::string> &key)
: db(db), key(key) {}
void finish(int r) override {
db->rmkey(key.first, key.second);
}
};
using KeyValueDB::TransactionImpl::rmkey;
using KeyValueDB::TransactionImpl::set;
void rmkey(const std::string &prefix, const std::string &key) override {
on_commit.push_back(new RmKeysOp(db, std::make_pair(prefix, key)));
}
struct RmKeysByPrefixOp : public Context {
KeyValueDBMemory *db;
std::string prefix;
RmKeysByPrefixOp(KeyValueDBMemory *db,
const std::string &prefix)
: db(db), prefix(prefix) {}
void finish(int r) override {
db->rmkeys_by_prefix(prefix);
}
};
void rmkeys_by_prefix(const std::string &prefix) override {
on_commit.push_back(new RmKeysByPrefixOp(db, prefix));
}
struct RmRangeKeys: public Context {
KeyValueDBMemory *db;
std::string prefix, start, end;
RmRangeKeys(KeyValueDBMemory *db, const std::string &prefix, const std::string &s, const std::string &e)
: db(db), prefix(prefix), start(s), end(e) {}
void finish(int r) {
db->rm_range_keys(prefix, start, end);
}
};
void rm_range_keys(const std::string &prefix, const std::string &start, const std::string &end) {
on_commit.push_back(new RmRangeKeys(db, prefix, start, end));
}
int complete() {
for (auto i = on_commit.begin();
i != on_commit.end();
on_commit.erase(i++)) {
(*i)->complete(0);
}
return 0;
}
~TransactionImpl_() override {
for (auto i = on_commit.begin();
i != on_commit.end();
on_commit.erase(i++)) {
delete *i;
}
}
};
Transaction get_transaction() override {
return Transaction(new TransactionImpl_(this));
}
int submit_transaction(Transaction trans) override {
return static_cast<TransactionImpl_*>(trans.get())->complete();
}
uint64_t get_estimated_size(std::map<std::string,uint64_t> &extras) override {
uint64_t total_size = 0;
for (auto& [key, bl] : db) {
string prefix = key.first;
uint64_t sz = bl.length();
total_size += sz;
if (extras.count(prefix) == 0)
extras[prefix] = 0;
extras[prefix] += sz;
}
return total_size;
}
private:
bool exists_prefix(const std::string &prefix) {
std::map<std::pair<std::string,std::string>,bufferlist>::iterator it;
it = db.lower_bound(std::make_pair(prefix, ""));
return ((it != db.end()) && ((*it).first.first == prefix));
}
friend class WholeSpaceMemIterator;
public:
WholeSpaceIterator get_wholespace_iterator(IteratorOpts opts = 0) override;
};
| 4,938 | 25.132275 | 110 |
h
|
null |
ceph-main/src/test/ObjectMap/test_keyvaluedb_atomicity.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include <pthread.h>
#include "include/buffer.h"
#include "kv/KeyValueDB.h"
#include <sys/types.h>
#include <dirent.h>
#include <string>
#include <vector>
#include <boost/scoped_ptr.hpp>
#include <iostream>
#include <sstream>
#include "stdlib.h"
#include "global/global_context.h"
#include "global/global_init.h"
using namespace std;
const string CONTROL_PREFIX = "CONTROL";
const string PRIMARY_PREFIX = "PREFIX";
const int NUM_COPIES = 100;
const int NUM_THREADS = 30;
string prefix_gen(int i) {
stringstream ss;
ss << PRIMARY_PREFIX << "_" << i << std::endl;
return ss.str();
}
int verify(KeyValueDB *db) {
// Verify
{
map<int, KeyValueDB::Iterator> iterators;
for (int i = 0; i < NUM_COPIES; ++i) {
iterators[i] = db->get_iterator(prefix_gen(i));
iterators[i]->seek_to_first();
}
while (iterators.rbegin()->second->valid()) {
for (map<int, KeyValueDB::Iterator>::iterator i = iterators.begin();
i != iterators.end();
++i) {
ceph_assert(i->second->valid());
ceph_assert(i->second->key() == iterators.rbegin()->second->key());
bufferlist r = i->second->value();
bufferlist l = iterators.rbegin()->second->value();
i->second->next();
}
}
for (map<int, KeyValueDB::Iterator>::iterator i = iterators.begin();
i != iterators.end();
++i) {
ceph_assert(!i->second->valid());
}
}
return 0;
}
void *write(void *_db) {
KeyValueDB *db = static_cast<KeyValueDB*>(_db);
std::cout << "Writing..." << std::endl;
for (int i = 0; i < 12000; ++i) {
if (!(i % 10)) {
std::cout << "Iteration: " << i << std::endl;
}
int key_num = rand();
stringstream key;
key << key_num << std::endl;
map<string, bufferlist> to_set;
stringstream val;
val << i << std::endl;
bufferptr bp(val.str().c_str(), val.str().size() + 1);
to_set[key.str()].push_back(bp);
KeyValueDB::Transaction t = db->get_transaction();
for (int j = 0; j < NUM_COPIES; ++j) {
t->set(prefix_gen(j), to_set);
}
ceph_assert(!db->submit_transaction(t));
}
return 0;
}
int main() {
char *path = getenv("OBJECT_MAP_PATH");
boost::scoped_ptr< KeyValueDB > db;
if (!path) {
std::cerr << "No path found, OBJECT_MAP_PATH undefined" << std::endl;
return 0;
}
string strpath(path);
std::cerr << "Using path: " << strpath << std::endl;
std::vector<const char*> args;
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY, CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
KeyValueDB *store = KeyValueDB::create(g_ceph_context, "rocksdb", strpath);
ceph_assert(!store->create_and_open(std::cerr));
db.reset(store);
verify(db.get());
vector<pthread_t> threads(NUM_THREADS);
for (vector<pthread_t>::iterator i = threads.begin();
i != threads.end();
++i) {
pthread_create(&*i, 0, &write, static_cast<void *>(db.get()));
}
for (vector<pthread_t>::iterator i = threads.begin();
i != threads.end();
++i) {
void *tmp;
pthread_join(*i, &tmp);
}
verify(db.get());
}
| 3,191 | 26.282051 | 77 |
cc
|
null |
ceph-main/src/test/ObjectMap/test_keyvaluedb_iterators.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2012 Inktank, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#include <map>
#include <set>
#include <deque>
#include <boost/scoped_ptr.hpp>
#include "test/ObjectMap/KeyValueDBMemory.h"
#include "kv/KeyValueDB.h"
#include <sys/types.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "gtest/gtest.h"
using namespace std;
string store_path;
class IteratorTest : public ::testing::Test
{
public:
boost::scoped_ptr<KeyValueDB> db;
boost::scoped_ptr<KeyValueDBMemory> mock;
void SetUp() override {
ceph_assert(!store_path.empty());
KeyValueDB *db_ptr = KeyValueDB::create(g_ceph_context, "rocksdb", store_path);
ceph_assert(!db_ptr->create_and_open(std::cerr));
db.reset(db_ptr);
mock.reset(new KeyValueDBMemory());
}
void TearDown() override { }
::testing::AssertionResult validate_db_clear(KeyValueDB *store) {
KeyValueDB::WholeSpaceIterator it = store->get_wholespace_iterator();
it->seek_to_first();
while (it->valid()) {
pair<string,string> k = it->raw_key();
if (mock->db.count(k)) {
return ::testing::AssertionFailure()
<< __func__
<< " mock store count " << mock->db.count(k)
<< " key(" << k.first << "," << k.second << ")";
}
it->next();
}
return ::testing::AssertionSuccess();
}
::testing::AssertionResult validate_db_match() {
KeyValueDB::WholeSpaceIterator it = db->get_wholespace_iterator();
it->seek_to_first();
while (it->valid()) {
pair<string, string> k = it->raw_key();
if (!mock->db.count(k)) {
return ::testing::AssertionFailure()
<< __func__
<< " mock db.count() " << mock->db.count(k)
<< " key(" << k.first << "," << k.second << ")";
}
bufferlist it_bl = it->value();
bufferlist mock_bl = mock->db[k];
string it_val = _bl_to_str(it_bl);
string mock_val = _bl_to_str(mock_bl);
if (it_val != mock_val) {
return ::testing::AssertionFailure()
<< __func__
<< " key(" << k.first << "," << k.second << ")"
<< " mismatch db value(" << it_val << ")"
<< " mock value(" << mock_val << ")";
}
it->next();
}
return ::testing::AssertionSuccess();
}
::testing::AssertionResult validate_iterator(
KeyValueDB::WholeSpaceIterator it,
string expected_prefix,
const string &expected_key,
const string &expected_value) {
if (!it->valid()) {
return ::testing::AssertionFailure()
<< __func__
<< " iterator not valid";
}
if (!it->raw_key_is_prefixed(expected_prefix)) {
return ::testing::AssertionFailure()
<< __func__
<< " expected raw_key_is_prefixed() == TRUE"
<< " got FALSE";
}
if (it->raw_key_is_prefixed("??__SomeUnexpectedValue__??")) {
return ::testing::AssertionFailure()
<< __func__
<< " expected raw_key_is_prefixed() == FALSE"
<< " got TRUE";
}
pair<string,string> key = it->raw_key();
if (expected_prefix != key.first) {
return ::testing::AssertionFailure()
<< __func__
<< " expected prefix '" << expected_prefix << "'"
<< " got prefix '" << key.first << "'";
}
if (expected_key != it->key()) {
return ::testing::AssertionFailure()
<< __func__
<< " expected key '" << expected_key << "'"
<< " got key '" << it->key() << "'";
}
if (it->key() != key.second) {
return ::testing::AssertionFailure()
<< __func__
<< " key '" << it->key() << "'"
<< " does not match"
<< " pair key '" << key.second << "'";
}
if (_bl_to_str(it->value()) != expected_value) {
return ::testing::AssertionFailure()
<< __func__
<< " key '(" << key.first << "," << key.second << ")''"
<< " expected value '" << expected_value << "'"
<< " got value '" << _bl_to_str(it->value()) << "'";
}
return ::testing::AssertionSuccess();
}
/**
* Checks if each key in the queue can be forward sequentially read from
* the iterator iter. All keys must be present and be prefixed with prefix,
* otherwise the validation will fail.
*
* Assumes that each key value must be based on the key name and generated
* by _gen_val().
*/
void validate_prefix(KeyValueDB::WholeSpaceIterator iter,
string &prefix, deque<string> &keys) {
while (!keys.empty()) {
ASSERT_TRUE(iter->valid());
string expected_key = keys.front();
keys.pop_front();
string expected_value = _gen_val_str(expected_key);
ASSERT_TRUE(validate_iterator(iter, prefix,
expected_key, expected_value));
iter->next();
}
}
/**
* Checks if each key in the queue can be backward sequentially read from
* the iterator iter. All keys must be present and be prefixed with prefix,
* otherwise the validation will fail.
*
* Assumes that each key value must be based on the key name and generated
* by _gen_val().
*/
void validate_prefix_backwards(KeyValueDB::WholeSpaceIterator iter,
string &prefix, deque<string> &keys) {
while (!keys.empty()) {
ASSERT_TRUE(iter->valid());
string expected_key = keys.front();
keys.pop_front();
string expected_value = _gen_val_str(expected_key);
ASSERT_TRUE(validate_iterator(iter, prefix,
expected_key, expected_value));
iter->prev();
}
}
void clear(KeyValueDB *store) {
KeyValueDB::WholeSpaceIterator it = store->get_wholespace_iterator();
it->seek_to_first();
KeyValueDB::Transaction t = store->get_transaction();
while (it->valid()) {
pair<string,string> k = it->raw_key();
t->rmkey(k.first, k.second);
it->next();
}
store->submit_transaction_sync(t);
}
string _bl_to_str(bufferlist val) {
string str(val.c_str(), val.length());
return str;
}
string _gen_val_str(const string &key) {
ostringstream ss;
ss << "##value##" << key << "##";
return ss.str();
}
bufferlist _gen_val(const string &key) {
bufferlist bl;
bl.append(_gen_val_str(key));
return bl;
}
void print_iterator(KeyValueDB::WholeSpaceIterator iter) {
if (!iter->valid()) {
std::cerr << __func__ << " iterator is not valid; stop." << std::endl;
return;
}
int i = 0;
while (iter->valid()) {
pair<string,string> k = iter->raw_key();
std::cerr << __func__
<< " pos " << (++i)
<< " key (" << k.first << "," << k.second << ")"
<< " value(" << _bl_to_str(iter->value()) << ")" << std::endl;
iter->next();
}
}
void print_db(KeyValueDB *store) {
KeyValueDB::WholeSpaceIterator it = store->get_wholespace_iterator();
it->seek_to_first();
print_iterator(it);
}
};
// ------- Remove Keys / Remove Keys By Prefix -------
class RmKeysTest : public IteratorTest
{
public:
string prefix1;
string prefix2;
string prefix3;
void init(KeyValueDB *db) {
KeyValueDB::Transaction tx = db->get_transaction();
tx->set(prefix1, "11", _gen_val("11"));
tx->set(prefix1, "12", _gen_val("12"));
tx->set(prefix1, "13", _gen_val("13"));
tx->set(prefix2, "21", _gen_val("21"));
tx->set(prefix2, "22", _gen_val("22"));
tx->set(prefix2, "23", _gen_val("23"));
tx->set(prefix3, "31", _gen_val("31"));
tx->set(prefix3, "32", _gen_val("32"));
tx->set(prefix3, "33", _gen_val("33"));
db->submit_transaction_sync(tx);
}
void SetUp() override {
IteratorTest::SetUp();
prefix1 = "_PREFIX_1_";
prefix2 = "_PREFIX_2_";
prefix3 = "_PREFIX_3_";
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
init(db.get());
init(mock.get());
ASSERT_TRUE(validate_db_match());
}
void TearDown() override {
IteratorTest::TearDown();
}
/**
* Test the transaction's rmkeys behavior when we remove a given prefix
* from the beginning of the key space, or from the end of the key space,
* or even simply in the middle.
*/
void RmKeysByPrefix(KeyValueDB *store) {
// remove prefix2 ; check if prefix1 remains, and then prefix3
KeyValueDB::Transaction tx = store->get_transaction();
// remove the prefix in the middle of the key space
tx->rmkeys_by_prefix(prefix2);
store->submit_transaction_sync(tx);
deque<string> key_deque;
KeyValueDB::WholeSpaceIterator iter = store->get_wholespace_iterator();
iter->seek_to_first();
// check for prefix1
key_deque.push_back("11");
key_deque.push_back("12");
key_deque.push_back("13");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
// check for prefix3
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("31");
key_deque.push_back("32");
key_deque.push_back("33");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
clear(store);
ASSERT_TRUE(validate_db_clear(store));
init(store);
// remove prefix1 ; check if prefix2 and then prefix3 remain
tx = store->get_transaction();
// remove the prefix at the beginning of the key space
tx->rmkeys_by_prefix(prefix1);
store->submit_transaction_sync(tx);
iter = store->get_wholespace_iterator();
iter->seek_to_first();
// check for prefix2
key_deque.clear();
key_deque.push_back("21");
key_deque.push_back("22");
key_deque.push_back("23");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
// check for prefix3
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("31");
key_deque.push_back("32");
key_deque.push_back("33");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
clear(store);
ASSERT_TRUE(validate_db_clear(store));
init(store);
// remove prefix3 ; check if prefix1 and then prefix2 remain
tx = store->get_transaction();
// remove the prefix at the end of the key space
tx->rmkeys_by_prefix(prefix3);
store->submit_transaction_sync(tx);
iter = store->get_wholespace_iterator();
iter->seek_to_first();
// check for prefix1
key_deque.clear();
key_deque.push_back("11");
key_deque.push_back("12");
key_deque.push_back("13");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
// check for prefix2
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("21");
key_deque.push_back("22");
key_deque.push_back("23");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
}
/**
* Test how the RocksDB's whole-space iterator behaves when we remove
* keys from the store while iterating over them.
*/
void RmKeysWhileIteratingSnapshot(KeyValueDB *store,
KeyValueDB::WholeSpaceIterator iter) {
SCOPED_TRACE("RmKeysWhileIteratingSnapshot");
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
KeyValueDB::Transaction t = store->get_transaction();
t->rmkey(prefix1, "11");
t->rmkey(prefix1, "12");
t->rmkey(prefix2, "23");
t->rmkey(prefix3, "33");
store->submit_transaction_sync(t);
deque<string> key_deque;
// check for prefix1
key_deque.push_back("11");
key_deque.push_back("12");
key_deque.push_back("13");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
// check for prefix2
key_deque.clear();
key_deque.push_back("21");
key_deque.push_back("22");
key_deque.push_back("23");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
// check for prefix3
key_deque.clear();
key_deque.push_back("31");
key_deque.push_back("32");
key_deque.push_back("33");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
iter->next();
ASSERT_FALSE(iter->valid());
// make sure those keys were removed from the store
KeyValueDB::WholeSpaceIterator tmp_it = store->get_wholespace_iterator();
tmp_it->seek_to_first();
ASSERT_TRUE(tmp_it->valid());
key_deque.clear();
key_deque.push_back("13");
validate_prefix(tmp_it, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(tmp_it->valid());
key_deque.clear();
key_deque.push_back("21");
key_deque.push_back("22");
validate_prefix(tmp_it, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(tmp_it->valid());
key_deque.clear();
key_deque.push_back("31");
key_deque.push_back("32");
validate_prefix(tmp_it, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(tmp_it->valid());
}
};
TEST_F(RmKeysTest, RmKeysByPrefixRocksDB)
{
SCOPED_TRACE("RocksDB");
RmKeysByPrefix(db.get());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(RmKeysTest, RmKeysByPrefixMockDB)
{
SCOPED_TRACE("Mock DB");
RmKeysByPrefix(mock.get());
ASSERT_FALSE(HasFatalFailure());
}
/**
* If you refer to function RmKeysTest::RmKeysWhileIteratingSnapshot(),
* you will notice that we seek the iterator to the first key, and then
* we go on to remove several keys from the underlying store, including
* the first couple keys.
*
* We would expect that during this test, as soon as we removed the keys
* from the store, the iterator would get invalid, or cause some sort of
* unexpected mess.
*
* Instead, the current version of RocksDB handles it perfectly, by making
* the iterator to use a snapshot instead of the store's real state. This
* way, RocksDBStore's whole-space iterator will behave much like its own
* whole-space snapshot iterator.
*
* However, this particular behavior of the iterator hasn't been documented
* on RocksDB, and we should assume that it can be changed at any point in
* time.
*
* Therefore, we keep this test, being exactly the same as the one for the
* whole-space snapshot iterator, as we currently assume they should behave
* identically. If this test fails, at some point, and the whole-space
* snapshot iterator passes, then it probably means that RocksDB changed
* how its iterator behaves.
*/
TEST_F(RmKeysTest, RmKeysWhileIteratingRocksDB)
{
SCOPED_TRACE("RocksDB -- WholeSpaceIterator");
RmKeysWhileIteratingSnapshot(db.get(), db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(RmKeysTest, RmKeysWhileIteratingMockDB)
{
std::cout << "There is no safe way to test key removal while iterating\n"
<< "over the mock store without using snapshots" << std::endl;
}
// ------- Set Keys / Update Values -------
class SetKeysTest : public IteratorTest
{
public:
string prefix1;
string prefix2;
void init(KeyValueDB *db) {
KeyValueDB::Transaction tx = db->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa"));
tx->set(prefix1, "ccc", _gen_val("ccc"));
tx->set(prefix1, "eee", _gen_val("eee"));
tx->set(prefix2, "vvv", _gen_val("vvv"));
tx->set(prefix2, "xxx", _gen_val("xxx"));
tx->set(prefix2, "zzz", _gen_val("zzz"));
db->submit_transaction_sync(tx);
}
void SetUp() override {
IteratorTest::SetUp();
prefix1 = "_PREFIX_1_";
prefix2 = "_PREFIX_2_";
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
init(db.get());
init(mock.get());
ASSERT_TRUE(validate_db_match());
}
void TearDown() override {
IteratorTest::TearDown();
}
/**
* Make sure that the iterator picks on new keys added if it hasn't yet
* iterated away from that position.
*
* This should only happen for the whole-space iterator when not using
* the snapshot version.
*
* We don't need to test the validity of all elements, but we do test
* inserting while moving from the first element to the last, using next()
* to move forward, and then we test the same behavior while iterating
* from the last element to the first, using prev() to move backwards.
*/
void SetKeysWhileIterating(KeyValueDB *store,
KeyValueDB::WholeSpaceIterator iter) {
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "aaa",
_gen_val_str("aaa")));
iter->next();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "ccc",
_bl_to_str(_gen_val("ccc"))));
// insert new key 'ddd' after 'ccc' and before 'eee'
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "ddd", _gen_val("ddd"));
store->submit_transaction_sync(tx);
iter->next();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "ddd",
_gen_val_str("ddd")));
iter->seek_to_last();
ASSERT_TRUE(iter->valid());
tx = store->get_transaction();
tx->set(prefix2, "yyy", _gen_val("yyy"));
store->submit_transaction_sync(tx);
iter->prev();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix2,
"yyy", _gen_val_str("yyy")));
}
/**
* Make sure that the whole-space snapshot iterator does not pick on new keys
* added to the store since we created the iterator, thus guaranteeing
* read-consistency.
*
* We don't need to test the validity of all elements, but we do test
* inserting while moving from the first element to the last, using next()
* to move forward, and then we test the same behavior while iterating
* from the last element to the first, using prev() to move backwards.
*/
void SetKeysWhileIteratingSnapshot(KeyValueDB *store,
KeyValueDB::WholeSpaceIterator iter) {
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "aaa",
_gen_val_str("aaa")));
iter->next();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "ccc",
_bl_to_str(_gen_val("ccc"))));
// insert new key 'ddd' after 'ccc' and before 'eee'
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "ddd", _gen_val("ddd"));
store->submit_transaction_sync(tx);
iter->next();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1, "eee",
_gen_val_str("eee")));
iter->seek_to_last();
ASSERT_TRUE(iter->valid());
tx = store->get_transaction();
tx->set(prefix2, "yyy", _gen_val("yyy"));
store->submit_transaction_sync(tx);
iter->prev();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix2,
"xxx", _gen_val_str("xxx")));
}
/**
* Make sure that the whole-space iterator is able to read values changed on
* the store, even after we moved to the updated position.
*
* This should only be possible when not using the whole-space snapshot
* version of the iterator.
*/
void UpdateValuesWhileIterating(KeyValueDB *store,
KeyValueDB::WholeSpaceIterator iter) {
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1,
"aaa", _gen_val_str("aaa")));
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa_1"));
store->submit_transaction_sync(tx);
ASSERT_TRUE(validate_iterator(iter, prefix1,
"aaa", _gen_val_str("aaa_1")));
iter->seek_to_last();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix2,
"zzz", _gen_val_str("zzz")));
tx = store->get_transaction();
tx->set(prefix2, "zzz", _gen_val("zzz_1"));
store->submit_transaction_sync(tx);
ASSERT_TRUE(validate_iterator(iter, prefix2,
"zzz", _gen_val_str("zzz_1")));
}
/**
* Make sure that the whole-space iterator is able to read values changed on
* the store, even after we moved to the updated position.
*
* This should only be possible when not using the whole-space snapshot
* version of the iterator.
*/
void UpdateValuesWhileIteratingSnapshot(
KeyValueDB *store,
KeyValueDB::WholeSpaceIterator iter) {
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix1,
"aaa", _gen_val_str("aaa")));
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa_1"));
store->submit_transaction_sync(tx);
ASSERT_TRUE(validate_iterator(iter, prefix1,
"aaa", _gen_val_str("aaa")));
iter->seek_to_last();
ASSERT_TRUE(iter->valid());
ASSERT_TRUE(validate_iterator(iter, prefix2,
"zzz", _gen_val_str("zzz")));
tx = store->get_transaction();
tx->set(prefix2, "zzz", _gen_val("zzz_1"));
store->submit_transaction_sync(tx);
ASSERT_TRUE(validate_iterator(iter, prefix2,
"zzz", _gen_val_str("zzz")));
// check those values were really changed in the store
KeyValueDB::WholeSpaceIterator tmp_iter = store->get_wholespace_iterator();
tmp_iter->seek_to_first();
ASSERT_TRUE(tmp_iter->valid());
ASSERT_TRUE(validate_iterator(tmp_iter, prefix1,
"aaa", _gen_val_str("aaa_1")));
tmp_iter->seek_to_last();
ASSERT_TRUE(tmp_iter->valid());
ASSERT_TRUE(validate_iterator(tmp_iter, prefix2,
"zzz", _gen_val_str("zzz_1")));
}
};
TEST_F(SetKeysTest, DISABLED_SetKeysWhileIteratingRocksDB)
{
SCOPED_TRACE("RocksDB: SetKeysWhileIteratingRocksDB");
SetKeysWhileIterating(db.get(), db->get_wholespace_iterator());
ASSERT_TRUE(HasFatalFailure());
}
TEST_F(SetKeysTest, SetKeysWhileIteratingMockDB)
{
SCOPED_TRACE("Mock DB: SetKeysWhileIteratingMockDB");
SetKeysWhileIterating(mock.get(), mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SetKeysTest, DISABLED_UpdateValuesWhileIteratingRocksDB)
{
SCOPED_TRACE("RocksDB: UpdateValuesWhileIteratingRocksDB");
UpdateValuesWhileIterating(db.get(), db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SetKeysTest, UpdateValuesWhileIteratingMockDB)
{
SCOPED_TRACE("MockDB: UpdateValuesWhileIteratingMockDB");
UpdateValuesWhileIterating(mock.get(), mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
class BoundsTest : public IteratorTest
{
public:
string prefix1;
string prefix2;
string prefix3;
void init(KeyValueDB *store) {
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa"));
tx->set(prefix1, "ccc", _gen_val("ccc"));
tx->set(prefix1, "eee", _gen_val("eee"));
tx->set(prefix2, "vvv", _gen_val("vvv"));
tx->set(prefix2, "xxx", _gen_val("xxx"));
tx->set(prefix2, "zzz", _gen_val("zzz"));
tx->set(prefix3, "aaa", _gen_val("aaa"));
tx->set(prefix3, "mmm", _gen_val("mmm"));
tx->set(prefix3, "yyy", _gen_val("yyy"));
store->submit_transaction_sync(tx);
}
void SetUp() override {
IteratorTest::SetUp();
prefix1 = "_PREFIX_1_";
prefix2 = "_PREFIX_2_";
prefix3 = "_PREFIX_4_";
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
init(db.get());
init(mock.get());
ASSERT_TRUE(validate_db_match());
}
void TearDown() override {
IteratorTest::TearDown();
}
void LowerBoundWithEmptyKeyOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// see what happens when we have an empty key and try to get to the
// first available prefix
iter->lower_bound(prefix1, "");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// if we got here without problems, then it is safe to assume the
// remaining prefixes are intact.
// see what happens when we have an empty key and try to get to the
// middle of the key-space
iter->lower_bound(prefix2, "");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("vvv");
key_deque.push_back("xxx");
key_deque.push_back("zzz");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// if we got here without problems, then it is safe to assume the
// remaining prefixes are intact.
// see what happens when we have an empty key and try to get to the
// last prefix on the key-space
iter->lower_bound(prefix3, "");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
key_deque.push_back("mmm");
key_deque.push_back("yyy");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
// we reached the end of the key_space, so the iterator should no longer
// be valid
// see what happens when we look for an inexistent prefix, that will
// compare higher than the existing prefixes, with an empty key
// expected: reach the store's end; iterator becomes invalid
iter->lower_bound("_PREFIX_9_", "");
ASSERT_FALSE(iter->valid());
// see what happens when we look for an inexistent prefix, that will
// compare lower than the existing prefixes, with an empty key
// expected: find the first prefix; iterator is valid
iter->lower_bound("_PREFIX_0_", "");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// see what happens when we look for an empty prefix (that should compare
// lower than any existing prefixes)
// expected: find the first prefix; iterator is valid
iter->lower_bound("", "");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void LowerBoundWithEmptyPrefixOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// check for an empty prefix, with key 'aaa'. Since this key is shared
// among two different prefixes, it is relevant to check which will be
// found first.
// expected: find key (prefix1, aaa); iterator is valid
iter->lower_bound("", "aaa");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// since we found prefix1, it is safe to assume that the remaining
// prefixes (prefix2 and prefix3) will follow
// any lower_bound operation with an empty prefix should always put the
// iterator in the first key in the key-space, despite what key is
// specified. This means that looking for ("","AAAAAAAAAA") should
// also position the iterator on (prefix1, aaa).
// expected: find key (prefix1, aaa); iterator is valid
iter->lower_bound("", "AAAAAAAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// note: this test is a duplicate of the one in the function above. Why?
// Well, because it also fits here (being its prefix empty), and one could
// very well run solely this test (instead of the whole battery) and would
// certainly expect this case to be tested.
// see what happens when we look for an empty prefix (that should compare
// lower than any existing prefixes)
// expected: find the first prefix; iterator is valid
iter->lower_bound("", "");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void LowerBoundOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// check that we find the first key in the store
// expected: find (prefix1, aaa); iterator is valid
iter->lower_bound(prefix1, "aaa");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that we find the last key in the store
// expected: find (prefix3, yyy); iterator is valid
iter->lower_bound(prefix3, "yyy");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("yyy");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_0_' will
// always result in the first value of prefix1 (prefix1,"aaa")
// expected: find (prefix1, aaa); iterator is valid
iter->lower_bound("_PREFIX_0_", "AAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_3_' will
// always result in the first value of prefix3 (prefix4,"aaa")
// expected: find (prefix3, aaa); iterator is valid
iter->lower_bound("_PREFIX_3_", "AAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_9_' will
// always result in an invalid iterator.
// expected: iterator is invalid
iter->lower_bound("_PREFIX_9_", "AAAAA");
ASSERT_FALSE(iter->valid());
}
void UpperBoundWithEmptyKeyOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// check that looking for (prefix1, "") will result in finding
// the first key in prefix1 (prefix1, "aaa")
// expected: find (prefix1, aaa); iterator is valid
iter->upper_bound(prefix1, "");
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for (prefix2, "") will result in finding
// the first key in prefix2 (prefix2, vvv)
// expected: find (prefix2, aaa); iterator is valid
iter->upper_bound(prefix2, "");
key_deque.push_back("vvv");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for (prefix3, "") will result in finding
// the first key in prefix3 (prefix3, aaa)
// expected: find (prefix3, aaa); iterator is valid
iter->upper_bound(prefix3, "");
key_deque.push_back("aaa");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// see what happens when we look for an inexistent prefix, that will
// compare higher than the existing prefixes, with an empty key
// expected: reach the store's end; iterator becomes invalid
iter->upper_bound("_PREFIX_9_", "");
ASSERT_FALSE(iter->valid());
// see what happens when we look for an inexistent prefix, that will
// compare lower than the existing prefixes, with an empty key
// expected: find the first prefix; iterator is valid
iter->upper_bound("_PREFIX_0_", "");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// see what happens when we look for an empty prefix (that should compare
// lower than any existing prefixes)
// expected: find the first prefix; iterator is valid
iter->upper_bound("", "");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void UpperBoundWithEmptyPrefixOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// check for an empty prefix, with key 'aaa'. Since this key is shared
// among two different prefixes, it is relevant to check which will be
// found first.
// expected: find key (prefix1, aaa); iterator is valid
iter->upper_bound("", "aaa");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// any upper_bound operation with an empty prefix should always put the
// iterator in the first key whose prefix compares greater, despite the
// key that is specified. This means that looking for ("","AAAAAAAAAA")
// should position the iterator on (prefix1, aaa).
// expected: find key (prefix1, aaa); iterator is valid
iter->upper_bound("", "AAAAAAAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// note: this test is a duplicate of the one in the function above. Why?
// Well, because it also fits here (being its prefix empty), and one could
// very well run solely this test (instead of the whole battery) and would
// certainly expect this case to be tested.
// see what happens when we look for an empty prefix (that should compare
// lower than any existing prefixes)
// expected: find the first prefix; iterator is valid
iter->upper_bound("", "");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void UpperBoundOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// check that we find the second key in the store
// expected: find (prefix1, ccc); iterator is valid
iter->upper_bound(prefix1, "bbb");
ASSERT_TRUE(iter->valid());
key_deque.push_back("ccc");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that we find the last key in the store
// expected: find (prefix3, yyy); iterator is valid
iter->upper_bound(prefix3, "xxx");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("yyy");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_0_' will
// always result in the first value of prefix1 (prefix1,"aaa")
// expected: find (prefix1, aaa); iterator is valid
iter->upper_bound("_PREFIX_0_", "AAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_3_' will
// always result in the first value of prefix3 (prefix3,"aaa")
// expected: find (prefix3, aaa); iterator is valid
iter->upper_bound("_PREFIX_3_", "AAAAA");
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix3, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// check that looking for non-existent prefix '_PREFIX_9_' will
// always result in an invalid iterator.
// expected: iterator is invalid
iter->upper_bound("_PREFIX_9_", "AAAAA");
ASSERT_FALSE(iter->valid());
}
};
TEST_F(BoundsTest, LowerBoundWithEmptyKeyOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Lower Bound, Empty Key, Whole-Space Iterator");
LowerBoundWithEmptyKeyOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, LowerBoundWithEmptyKeyOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Lower Bound, Empty Key, Whole-Space Iterator");
LowerBoundWithEmptyKeyOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, LowerBoundWithEmptyPrefixOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Lower Bound, Empty Prefix, Whole-Space Iterator");
LowerBoundWithEmptyPrefixOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, LowerBoundWithEmptyPrefixOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Lower Bound, Empty Prefix, Whole-Space Iterator");
LowerBoundWithEmptyPrefixOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, LowerBoundOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Lower Bound, Whole-Space Iterator");
LowerBoundOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, LowerBoundOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Lower Bound, Whole-Space Iterator");
LowerBoundOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundWithEmptyKeyOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Upper Bound, Empty Key, Whole-Space Iterator");
UpperBoundWithEmptyKeyOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundWithEmptyKeyOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Upper Bound, Empty Key, Whole-Space Iterator");
UpperBoundWithEmptyKeyOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundWithEmptyPrefixOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Upper Bound, Empty Prefix, Whole-Space Iterator");
UpperBoundWithEmptyPrefixOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundWithEmptyPrefixOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Upper Bound, Empty Prefix, Whole-Space Iterator");
UpperBoundWithEmptyPrefixOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundOnWholeSpaceIteratorRocksDB)
{
SCOPED_TRACE("RocksDB: Upper Bound, Whole-Space Iterator");
UpperBoundOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(BoundsTest, UpperBoundOnWholeSpaceIteratorMockDB)
{
SCOPED_TRACE("MockDB: Upper Bound, Whole-Space Iterator");
UpperBoundOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
class SeeksTest : public IteratorTest
{
public:
string prefix0;
string prefix1;
string prefix2;
string prefix3;
string prefix4;
string prefix5;
void init(KeyValueDB *store) {
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa"));
tx->set(prefix1, "ccc", _gen_val("ccc"));
tx->set(prefix1, "eee", _gen_val("eee"));
tx->set(prefix2, "vvv", _gen_val("vvv"));
tx->set(prefix2, "xxx", _gen_val("xxx"));
tx->set(prefix2, "zzz", _gen_val("zzz"));
tx->set(prefix4, "aaa", _gen_val("aaa"));
tx->set(prefix4, "mmm", _gen_val("mmm"));
tx->set(prefix4, "yyy", _gen_val("yyy"));
store->submit_transaction_sync(tx);
}
void SetUp() override {
IteratorTest::SetUp();
prefix0 = "_PREFIX_0_";
prefix1 = "_PREFIX_1_";
prefix2 = "_PREFIX_2_";
prefix3 = "_PREFIX_3_";
prefix4 = "_PREFIX_4_";
prefix5 = "_PREFIX_5_";
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
init(db.get());
init(mock.get());
ASSERT_TRUE(validate_db_match());
}
void TearDown() override {
IteratorTest::TearDown();
}
void SeekToFirstOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
iter->seek_to_first();
ASSERT_TRUE(iter->valid());
deque<string> key_deque;
key_deque.push_back("aaa");
key_deque.push_back("ccc");
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void SeekToFirstWithPrefixOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// if the prefix is empty, we must end up seeking to the first key.
// expected: seek to (prefix1, aaa); iterator is valid
iter->seek_to_first("");
ASSERT_TRUE(iter->valid());
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to non-existent prefix that compares lower than the
// first available prefix
// expected: seek to (prefix1, aaa); iterator is valid
iter->seek_to_first(prefix0);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to non-existent prefix
// expected: seek to (prefix4, aaa); iterator is valid
iter->seek_to_first(prefix3);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix4, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to non-existent prefix that compares greater than the
// last available prefix
// expected: iterator is invalid
iter->seek_to_first(prefix5);
ASSERT_FALSE(iter->valid());
// try seeking to the first prefix and make sure we end up in its first
// position
// expected: seek to (prefix1,aaa); iterator is valid
iter->seek_to_first(prefix1);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to the second prefix and make sure we end up in its
// first position
// expected: seek to (prefix2,vvv); iterator is valid
iter->seek_to_first(prefix2);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("vvv");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to the last prefix and make sure we end up in its
// first position
// expected: seek to (prefix4,aaa); iterator is valid
iter->seek_to_first(prefix4);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("aaa");
validate_prefix(iter, prefix4, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
}
void SeekToLastOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
iter->seek_to_last();
key_deque.push_back("yyy");
validate_prefix(iter, prefix4, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
}
void SeekToLastWithPrefixOnWholeSpaceIterator(
KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
// if the prefix is empty, we must end up seeking to last position
// that has an empty prefix, or to the previous position to the first
// position whose prefix compares higher than empty.
// expected: iterator is invalid (because (prefix1,aaa) is the first
// position that compared higher than an empty prefix)
iter->seek_to_last("");
ASSERT_FALSE(iter->valid());
// try seeking to non-existent prefix that compares lower than the
// first available prefix
// expected: iterator is invalid (because (prefix1,aaa) is the first
// position that compared higher than prefix0)
iter->seek_to_last(prefix0);
ASSERT_FALSE(iter->valid());
// try seeking to non-existent prefix
// expected: seek to (prefix2, zzz); iterator is valid
iter->seek_to_last(prefix3);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("zzz");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to non-existent prefix that compares greater than the
// last available prefix
// expected: iterator is in the last position of the store;
// i.e., (prefix4,yyy)
iter->seek_to_last(prefix5);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("yyy");
validate_prefix(iter, prefix4, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
// try seeking to the first prefix and make sure we end up in its last
// position
// expected: seek to (prefix1,eee); iterator is valid
iter->seek_to_last(prefix1);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("eee");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to the second prefix and make sure we end up in its
// last position
// expected: seek to (prefix2,vvv); iterator is valid
iter->seek_to_last(prefix2);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("zzz");
validate_prefix(iter, prefix2, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_TRUE(iter->valid());
// try seeking to the last prefix and make sure we end up in its
// last position
// expected: seek to (prefix4,aaa); iterator is valid
iter->seek_to_last(prefix4);
ASSERT_TRUE(iter->valid());
key_deque.clear();
key_deque.push_back("yyy");
validate_prefix(iter, prefix4, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
}
};
TEST_F(SeeksTest, SeekToFirstOnWholeSpaceIteratorRocksDB) {
SCOPED_TRACE("RocksDB: Seek To First, Whole Space Iterator");
SeekToFirstOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToFirstOnWholeSpaceIteratorMockDB) {
SCOPED_TRACE("MockDB: Seek To First, Whole Space Iterator");
SeekToFirstOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToFirstWithPrefixOnWholeSpaceIteratorRocksDB) {
SCOPED_TRACE("RocksDB: Seek To First, With Prefix, Whole Space Iterator");
SeekToFirstWithPrefixOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToFirstWithPrefixOnWholeSpaceIteratorMockDB) {
SCOPED_TRACE("MockDB: Seek To First, With Prefix, Whole Space Iterator");
SeekToFirstWithPrefixOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToLastOnWholeSpaceIteratorRocksDB) {
SCOPED_TRACE("RocksDB: Seek To Last, Whole Space Iterator");
SeekToLastOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToLastOnWholeSpaceIteratorMockDB) {
SCOPED_TRACE("MockDB: Seek To Last, Whole Space Iterator");
SeekToLastOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToLastWithPrefixOnWholeSpaceIteratorRocksDB) {
SCOPED_TRACE("RocksDB: Seek To Last, With Prefix, Whole Space Iterator");
SeekToLastWithPrefixOnWholeSpaceIterator(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(SeeksTest, SeekToLastWithPrefixOnWholeSpaceIteratorMockDB) {
SCOPED_TRACE("MockDB: Seek To Last, With Prefix, Whole Space Iterator");
SeekToLastWithPrefixOnWholeSpaceIterator(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
class KeySpaceIteration : public IteratorTest
{
public:
string prefix1;
void init(KeyValueDB *store) {
KeyValueDB::Transaction tx = store->get_transaction();
tx->set(prefix1, "aaa", _gen_val("aaa"));
tx->set(prefix1, "vvv", _gen_val("vvv"));
tx->set(prefix1, "zzz", _gen_val("zzz"));
store->submit_transaction_sync(tx);
}
void SetUp() override {
IteratorTest::SetUp();
prefix1 = "_PREFIX_1_";
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
init(db.get());
init(mock.get());
ASSERT_TRUE(validate_db_match());
}
void TearDown() override {
IteratorTest::TearDown();
}
void ForwardIteration(KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
iter->seek_to_first();
key_deque.push_back("aaa");
key_deque.push_back("vvv");
key_deque.push_back("zzz");
validate_prefix(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
}
void BackwardIteration(KeyValueDB::WholeSpaceIterator iter) {
deque<string> key_deque;
iter->seek_to_last();
key_deque.push_back("zzz");
key_deque.push_back("vvv");
key_deque.push_back("aaa");
validate_prefix_backwards(iter, prefix1, key_deque);
ASSERT_FALSE(HasFatalFailure());
ASSERT_FALSE(iter->valid());
}
};
TEST_F(KeySpaceIteration, ForwardIterationRocksDB)
{
SCOPED_TRACE("RocksDB: Forward Iteration, Whole Space Iterator");
ForwardIteration(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(KeySpaceIteration, ForwardIterationMockDB) {
SCOPED_TRACE("MockDB: Forward Iteration, Whole Space Iterator");
ForwardIteration(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(KeySpaceIteration, BackwardIterationRocksDB)
{
SCOPED_TRACE("RocksDB: Backward Iteration, Whole Space Iterator");
BackwardIteration(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(KeySpaceIteration, BackwardIterationMockDB) {
SCOPED_TRACE("MockDB: Backward Iteration, Whole Space Iterator");
BackwardIteration(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
class EmptyStore : public IteratorTest
{
public:
void SetUp() override {
IteratorTest::SetUp();
clear(db.get());
ASSERT_TRUE(validate_db_clear(db.get()));
clear(mock.get());
ASSERT_TRUE(validate_db_match());
}
void SeekToFirst(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->seek_to_first();
ASSERT_FALSE(iter->valid());
}
void SeekToFirstWithPrefix(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->seek_to_first("prefix");
ASSERT_FALSE(iter->valid());
}
void SeekToLast(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->seek_to_last();
ASSERT_FALSE(iter->valid());
}
void SeekToLastWithPrefix(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->seek_to_last("prefix");
ASSERT_FALSE(iter->valid());
}
void LowerBound(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->lower_bound("prefix", "");
ASSERT_FALSE(iter->valid());
// expected: iterator is invalid
iter->lower_bound("", "key");
ASSERT_FALSE(iter->valid());
// expected: iterator is invalid
iter->lower_bound("prefix", "key");
ASSERT_FALSE(iter->valid());
}
void UpperBound(KeyValueDB::WholeSpaceIterator iter) {
// expected: iterator is invalid
iter->upper_bound("prefix", "");
ASSERT_FALSE(iter->valid());
// expected: iterator is invalid
iter->upper_bound("", "key");
ASSERT_FALSE(iter->valid());
// expected: iterator is invalid
iter->upper_bound("prefix", "key");
ASSERT_FALSE(iter->valid());
}
};
TEST_F(EmptyStore, SeekToFirstRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Seek To First");
SeekToFirst(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToFirstMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Seek To First");
SeekToFirst(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToFirstWithPrefixRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Seek To First With Prefix");
SeekToFirstWithPrefix(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToFirstWithPrefixMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Seek To First With Prefix");
SeekToFirstWithPrefix(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToLastRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Seek To Last");
SeekToLast(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToLastMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Seek To Last");
SeekToLast(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToLastWithPrefixRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Seek To Last With Prefix");
SeekToLastWithPrefix(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, SeekToLastWithPrefixMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Seek To Last With Prefix");
SeekToLastWithPrefix(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, LowerBoundRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Lower Bound");
LowerBound(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, LowerBoundMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Lower Bound");
LowerBound(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, UpperBoundRocksDB)
{
SCOPED_TRACE("RocksDB: Empty Store, Upper Bound");
UpperBound(db->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
TEST_F(EmptyStore, UpperBoundMockDB)
{
SCOPED_TRACE("MockDB: Empty Store, Upper Bound");
UpperBound(mock->get_wholespace_iterator());
ASSERT_FALSE(HasFatalFailure());
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
if (argc < 2) {
std::cerr << "Usage: " << argv[0]
<< "[ceph_options] [gtest_options] <store_path>" << std::endl;
return 1;
}
store_path = string(argv[1]);
return RUN_ALL_TESTS();
}
| 55,602 | 30.646557 | 123 |
cc
|
null |
ceph-main/src/test/ObjectMap/test_object_map.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include <iterator>
#include <map>
#include <set>
#include <boost/scoped_ptr.hpp>
#include "include/buffer.h"
#include "test/ObjectMap/KeyValueDBMemory.h"
#include "kv/KeyValueDB.h"
#include "os/DBObjectMap.h"
#include <sys/types.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include <dirent.h>
#include "gtest/gtest.h"
#include "stdlib.h"
using namespace std;
template <typename T>
typename T::iterator rand_choose(T &cont) {
if (std::empty(cont)) {
return std::end(cont);
}
return std::next(std::begin(cont), rand() % cont.size());
}
string num_str(unsigned i) {
char buf[100];
snprintf(buf, sizeof(buf), "%.10u", i);
return string(buf);
}
class ObjectMapTester {
public:
ObjectMap *db;
set<string> key_space;
set<string> object_name_space;
map<string, map<string, string> > omap;
map<string, string > hmap;
map<string, map<string, string> > xattrs;
unsigned seq;
ObjectMapTester() : db(0), seq(0) {}
string val_from_key(const string &object, const string &key) {
return object + "_" + key + "_" + num_str(seq++);
}
void set_key(const string &objname, const string &key, const string &value) {
set_key(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key, value);
}
void set_xattr(const string &objname, const string &key, const string &value) {
set_xattr(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key, value);
}
void set_key(ghobject_t hoid,
string key, string value) {
map<string, bufferlist> to_write;
bufferptr bp(value.c_str(), value.size());
bufferlist bl;
bl.append(bp);
to_write.insert(make_pair(key, bl));
db->set_keys(hoid, to_write);
}
void set_keys(ghobject_t hoid, const map<string, string> &to_set) {
map<string, bufferlist> to_write;
for (auto &&i: to_set) {
bufferptr bp(i.second.data(), i.second.size());
bufferlist bl;
bl.append(bp);
to_write.insert(make_pair(i.first, bl));
}
db->set_keys(hoid, to_write);
}
void set_xattr(ghobject_t hoid,
string key, string value) {
map<string, bufferlist> to_write;
bufferptr bp(value.c_str(), value.size());
bufferlist bl;
bl.append(bp);
to_write.insert(make_pair(key, bl));
db->set_xattrs(hoid, to_write);
}
void set_header(const string &objname, const string &value) {
set_header(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
value);
}
void set_header(ghobject_t hoid,
const string &value) {
bufferlist header;
header.append(bufferptr(value.c_str(), value.size() + 1));
db->set_header(hoid, header);
}
int get_header(const string &objname, string *value) {
return get_header(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
value);
}
int get_header(ghobject_t hoid,
string *value) {
bufferlist header;
int r = db->get_header(hoid, &header);
if (r < 0)
return r;
if (header.length())
*value = string(header.c_str());
else
*value = string("");
return 0;
}
int get_xattr(const string &objname, const string &key, string *value) {
return get_xattr(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key, value);
}
int get_xattr(ghobject_t hoid,
string key, string *value) {
set<string> to_get;
to_get.insert(key);
map<string, bufferlist> got;
db->get_xattrs(hoid, to_get, &got);
if (!got.empty()) {
*value = string(got.begin()->second.c_str(),
got.begin()->second.length());
return 1;
} else {
return 0;
}
}
int get_key(const string &objname, const string &key, string *value) {
return get_key(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key, value);
}
int get_key(ghobject_t hoid,
string key, string *value) {
set<string> to_get;
to_get.insert(key);
map<string, bufferlist> got;
db->get_values(hoid, to_get, &got);
if (!got.empty()) {
if (value) {
*value = string(got.begin()->second.c_str(),
got.begin()->second.length());
}
return 1;
} else {
return 0;
}
}
void remove_key(const string &objname, const string &key) {
remove_key(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key);
}
void remove_keys(const string &objname, const set<string> &to_remove) {
remove_keys(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
to_remove);
}
void remove_key(ghobject_t hoid,
string key) {
set<string> to_remove;
to_remove.insert(key);
db->rm_keys(hoid, to_remove);
}
void remove_keys(ghobject_t hoid,
const set<string> &to_remove) {
db->rm_keys(hoid, to_remove);
}
void remove_xattr(const string &objname, const string &key) {
remove_xattr(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
key);
}
void remove_xattr(ghobject_t hoid,
string key) {
set<string> to_remove;
to_remove.insert(key);
db->remove_xattrs(hoid, to_remove);
}
void clone(const string &objname, const string &target) {
clone(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
ghobject_t(hobject_t(sobject_t(target, CEPH_NOSNAP))));
}
void clone(ghobject_t hoid,
ghobject_t hoid2) {
db->clone(hoid, hoid2);
}
void rename(const string &objname, const string &target) {
rename(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
ghobject_t(hobject_t(sobject_t(target, CEPH_NOSNAP))));
}
void rename(ghobject_t hoid,
ghobject_t hoid2) {
db->rename(hoid, hoid2);
}
void clear(const string &objname) {
clear(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))));
}
void legacy_clone(const string &objname, const string &target) {
legacy_clone(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))),
ghobject_t(hobject_t(sobject_t(target, CEPH_NOSNAP))));
}
void legacy_clone(ghobject_t hoid,
ghobject_t hoid2) {
db->legacy_clone(hoid, hoid2);
}
void clear(ghobject_t hoid) {
db->clear(hoid);
}
void clear_omap(const string &objname) {
clear_omap(ghobject_t(hobject_t(sobject_t(objname, CEPH_NOSNAP))));
}
void clear_omap(const ghobject_t &objname) {
db->clear_keys_header(objname);
}
void def_init() {
for (unsigned i = 0; i < 10000; ++i) {
key_space.insert("key_" + num_str(i));
}
for (unsigned i = 0; i < 100; ++i) {
object_name_space.insert("name_" + num_str(i));
}
}
void init_key_set(const set<string> &keys) {
key_space = keys;
}
void init_object_name_space(const set<string> &onamespace) {
object_name_space = onamespace;
}
void auto_set_xattr(ostream &out) {
set<string>::iterator key = rand_choose(key_space);
set<string>::iterator object = rand_choose(object_name_space);
string value = val_from_key(*object, *key);
xattrs[*object][*key] = value;
set_xattr(*object, *key, value);
out << "auto_set_xattr " << *object << ": " << *key << " -> "
<< value << std::endl;
}
void test_set_key(const string &obj, const string &key, const string &val) {
omap[obj][key] = val;
set_key(obj, key, val);
}
void test_set_keys(const string &obj, const map<string, string> &to_set) {
for (auto &&i: to_set) {
omap[obj][i.first] = i.second;
}
set_keys(
ghobject_t(hobject_t(sobject_t(obj, CEPH_NOSNAP))),
to_set);
}
void auto_set_keys(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
map<string, string> to_set;
unsigned amount = (rand() % 10) + 1;
for (unsigned i = 0; i < amount; ++i) {
set<string>::iterator key = rand_choose(key_space);
string value = val_from_key(*object, *key);
out << "auto_set_key " << *object << ": " << *key << " -> "
<< value << std::endl;
to_set.insert(make_pair(*key, value));
}
test_set_keys(*object, to_set);
}
void xattrs_on_object(const string &object, set<string> *out) {
if (!xattrs.count(object))
return;
const map<string, string> &xmap = xattrs.find(object)->second;
for (map<string, string>::const_iterator i = xmap.begin();
i != xmap.end();
++i) {
out->insert(i->first);
}
}
void keys_on_object(const string &object, set<string> *out) {
if (!omap.count(object))
return;
const map<string, string> &kmap = omap.find(object)->second;
for (map<string, string>::const_iterator i = kmap.begin();
i != kmap.end();
++i) {
out->insert(i->first);
}
}
void xattrs_off_object(const string &object, set<string> *out) {
*out = key_space;
set<string> xspace;
xattrs_on_object(object, &xspace);
for (set<string>::iterator i = xspace.begin();
i != xspace.end();
++i) {
out->erase(*i);
}
}
void keys_off_object(const string &object, set<string> *out) {
*out = key_space;
set<string> kspace;
keys_on_object(object, &kspace);
for (set<string>::iterator i = kspace.begin();
i != kspace.end();
++i) {
out->erase(*i);
}
}
int auto_check_present_xattr(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> xspace;
xattrs_on_object(*object, &xspace);
set<string>::iterator key = rand_choose(xspace);
if (key == xspace.end()) {
return 1;
}
string result;
int r = get_xattr(*object, *key, &result);
if (!r) {
out << "auto_check_present_key: failed to find key "
<< *key << " on object " << *object << std::endl;
return 0;
}
if (result != xattrs[*object][*key]) {
out << "auto_check_present_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found "
<< xattrs[*object][*key] << std::endl;
return 0;
}
out << "auto_check_present_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found "
<< xattrs[*object][*key] << std::endl;
return 1;
}
int auto_check_present_key(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> kspace;
keys_on_object(*object, &kspace);
set<string>::iterator key = rand_choose(kspace);
if (key == kspace.end()) {
return 1;
}
string result;
int r = get_key(*object, *key, &result);
if (!r) {
out << "auto_check_present_key: failed to find key "
<< *key << " on object " << *object << std::endl;
return 0;
}
if (result != omap[*object][*key]) {
out << "auto_check_present_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found "
<< omap[*object][*key] << std::endl;
return 0;
}
out << "auto_check_present_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found "
<< omap[*object][*key] << std::endl;
return 1;
}
int auto_check_absent_xattr(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> xspace;
xattrs_off_object(*object, &xspace);
set<string>::iterator key = rand_choose(xspace);
if (key == xspace.end()) {
return 1;
}
string result;
int r = get_xattr(*object, *key, &result);
if (!r) {
out << "auto_check_absent_key: did not find key "
<< *key << " on object " << *object << std::endl;
return 1;
}
out << "auto_check_basent_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found nothing"
<< std::endl;
return 0;
}
int auto_check_absent_key(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> kspace;
keys_off_object(*object, &kspace);
set<string>::iterator key = rand_choose(kspace);
if (key == kspace.end()) {
return 1;
}
string result;
int r = get_key(*object, *key, &result);
if (!r) {
out << "auto_check_absent_key: did not find key "
<< *key << " on object " << *object << std::endl;
return 1;
}
out << "auto_check_basent_key: for key "
<< *key << " on object " << *object
<< " found value " << result << " where we should have found nothing"
<< std::endl;
return 0;
}
void test_clone(const string &object, const string &target, ostream &out) {
clone(object, target);
if (!omap.count(object)) {
out << " source missing.";
omap.erase(target);
} else {
out << " source present.";
omap[target] = omap[object];
}
if (!hmap.count(object)) {
out << " hmap source missing." << std::endl;
hmap.erase(target);
} else {
out << " hmap source present." << std::endl;
hmap[target] = hmap[object];
}
if (!xattrs.count(object)) {
out << " hmap source missing." << std::endl;
xattrs.erase(target);
} else {
out << " hmap source present." << std::endl;
xattrs[target] = xattrs[object];
}
}
void auto_clone_key(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string>::iterator target = rand_choose(object_name_space);
while (target == object) {
target = rand_choose(object_name_space);
}
out << "clone " << *object << " to " << *target;
test_clone(*object, *target, out);
}
void test_remove_keys(const string &obj, const set<string> &to_remove) {
for (auto &&k: to_remove)
omap[obj].erase(k);
remove_keys(obj, to_remove);
}
void test_remove_key(const string &obj, const string &key) {
omap[obj].erase(key);
remove_key(obj, key);
}
void auto_remove_keys(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> kspace;
keys_on_object(*object, &kspace);
set<string> to_remove;
for (unsigned i = 0; i < 3; ++i) {
set<string>::iterator key = rand_choose(kspace);
if (key == kspace.end())
continue;
out << "removing " << *key << " from " << *object << std::endl;
to_remove.insert(*key);
}
test_remove_keys(*object, to_remove);
}
void auto_remove_xattr(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
set<string> kspace;
xattrs_on_object(*object, &kspace);
set<string>::iterator key = rand_choose(kspace);
if (key == kspace.end()) {
return;
}
out << "removing xattr " << *key << " from " << *object << std::endl;
xattrs[*object].erase(*key);
remove_xattr(*object, *key);
}
void auto_delete_object(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
out << "auto_delete_object " << *object << std::endl;
clear(*object);
omap.erase(*object);
hmap.erase(*object);
xattrs.erase(*object);
}
void test_clear(const string &obj) {
clear_omap(obj);
omap.erase(obj);
hmap.erase(obj);
}
void auto_clear_omap(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
out << "auto_clear_object " << *object << std::endl;
test_clear(*object);
}
void auto_write_header(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
string header = val_from_key(*object, "HEADER");
out << "auto_write_header: " << *object << " -> " << header << std::endl;
set_header(*object, header);
hmap[*object] = header;
}
int auto_verify_header(ostream &out) {
set<string>::iterator object = rand_choose(object_name_space);
out << "verify_header: " << *object << " ";
string header;
int r = get_header(*object, &header);
if (r < 0) {
ceph_abort();
}
if (header.size() == 0) {
if (hmap.count(*object)) {
out << " failed to find header " << hmap[*object] << std::endl;
return 0;
} else {
out << " found no header" << std::endl;
return 1;
}
}
if (!hmap.count(*object)) {
out << " found header " << header << " should have been empty"
<< std::endl;
return 0;
} else if (header == hmap[*object]) {
out << " found correct header " << header << std::endl;
return 1;
} else {
out << " found incorrect header " << header
<< " where we should have found " << hmap[*object] << std::endl;
return 0;
}
}
void verify_keys(const std::string &obj, ostream &out) {
set<string> in_db;
ObjectMap::ObjectMapIterator iter = db->get_iterator(
ghobject_t(hobject_t(sobject_t(obj, CEPH_NOSNAP))));
for (iter->seek_to_first(); iter->valid(); iter->next()) {
in_db.insert(iter->key());
}
bool err = false;
for (auto &&i: omap[obj]) {
if (!in_db.count(i.first)) {
out << __func__ << ": obj " << obj << " missing key "
<< i.first << std::endl;
err = true;
} else {
in_db.erase(i.first);
}
}
if (!in_db.empty()) {
out << __func__ << ": obj " << obj << " found extra keys "
<< in_db << std::endl;
err = true;
}
ASSERT_FALSE(err);
}
void auto_verify_objects(ostream &out) {
for (auto &&i: omap) {
verify_keys(i.first, out);
}
}
};
class ObjectMapTest : public ::testing::Test {
public:
boost::scoped_ptr< ObjectMap > db;
ObjectMapTester tester;
void SetUp() override {
char *path = getenv("OBJECT_MAP_PATH");
if (!path) {
db.reset(new DBObjectMap(g_ceph_context, new KeyValueDBMemory()));
tester.db = db.get();
return;
}
string strpath(path);
cerr << "using path " << strpath << std::endl;
KeyValueDB *store = KeyValueDB::create(g_ceph_context, "rocksdb", strpath);
ceph_assert(!store->create_and_open(cerr));
db.reset(new DBObjectMap(g_ceph_context, store));
tester.db = db.get();
}
void TearDown() override {
std::cerr << "Checking..." << std::endl;
ASSERT_EQ(0, db->check(std::cerr));
}
};
int main(int argc, char **argv) {
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
TEST_F(ObjectMapTest, CreateOneObject) {
ghobject_t hoid(hobject_t(sobject_t("foo", CEPH_NOSNAP)), 100, shard_id_t(0));
map<string, bufferlist> to_set;
string key("test");
string val("test_val");
bufferptr bp(val.c_str(), val.size());
bufferlist bl;
bl.append(bp);
to_set.insert(make_pair(key, bl));
ASSERT_EQ(db->set_keys(hoid, to_set), 0);
map<string, bufferlist> got;
set<string> to_get;
to_get.insert(key);
to_get.insert("not there");
db->get_values(hoid, to_get, &got);
ASSERT_EQ(got.size(), (unsigned)1);
ASSERT_EQ(string(got[key].c_str(), got[key].length()), val);
bufferlist header;
got.clear();
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)1);
ASSERT_EQ(string(got[key].c_str(), got[key].length()), val);
ASSERT_EQ(header.length(), (unsigned)0);
db->rm_keys(hoid, to_get);
got.clear();
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)0);
map<string, bufferlist> attrs;
attrs["attr1"] = bl;
db->set_xattrs(hoid, attrs);
db->set_header(hoid, bl);
db->clear_keys_header(hoid);
set<string> attrs_got;
db->get_all_xattrs(hoid, &attrs_got);
ASSERT_EQ(attrs_got.size(), 1U);
ASSERT_EQ(*(attrs_got.begin()), "attr1");
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)0);
ASSERT_EQ(header.length(), 0U);
got.clear();
db->clear(hoid);
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)0);
attrs_got.clear();
db->get_all_xattrs(hoid, &attrs_got);
ASSERT_EQ(attrs_got.size(), 0U);
}
TEST_F(ObjectMapTest, CloneOneObject) {
ghobject_t hoid(hobject_t(sobject_t("foo", CEPH_NOSNAP)), 200, shard_id_t(0));
ghobject_t hoid2(hobject_t(sobject_t("foo2", CEPH_NOSNAP)), 201, shard_id_t(1));
tester.set_key(hoid, "foo", "bar");
tester.set_key(hoid, "foo2", "bar2");
string result;
int r = tester.get_key(hoid, "foo", &result);
ASSERT_EQ(r, 1);
ASSERT_EQ(result, "bar");
db->clone(hoid, hoid2);
r = tester.get_key(hoid, "foo", &result);
ASSERT_EQ(r, 1);
ASSERT_EQ(result, "bar");
r = tester.get_key(hoid2, "foo", &result);
ASSERT_EQ(r, 1);
ASSERT_EQ(result, "bar");
tester.remove_key(hoid, "foo");
r = tester.get_key(hoid2, "foo", &result);
ASSERT_EQ(r, 1);
ASSERT_EQ(result, "bar");
r = tester.get_key(hoid, "foo", &result);
ASSERT_EQ(r, 0);
r = tester.get_key(hoid, "foo2", &result);
ASSERT_EQ(r, 1);
ASSERT_EQ(result, "bar2");
tester.set_key(hoid, "foo", "baz");
tester.remove_key(hoid, "foo");
r = tester.get_key(hoid, "foo", &result);
ASSERT_EQ(r, 0);
tester.set_key(hoid, "foo2", "baz");
tester.remove_key(hoid, "foo2");
r = tester.get_key(hoid, "foo2", &result);
ASSERT_EQ(r, 0);
map<string, bufferlist> got;
bufferlist header;
got.clear();
db->clear(hoid);
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)0);
got.clear();
r = db->clear(hoid2);
ASSERT_EQ(0, r);
db->get(hoid2, &header, &got);
ASSERT_EQ(got.size(), (unsigned)0);
tester.set_key(hoid, "baz", "bar");
got.clear();
db->get(hoid, &header, &got);
ASSERT_EQ(got.size(), (unsigned)1);
db->clear(hoid);
db->clear(hoid2);
}
TEST_F(ObjectMapTest, OddEvenClone) {
ghobject_t hoid(hobject_t(sobject_t("foo", CEPH_NOSNAP)));
ghobject_t hoid2(hobject_t(sobject_t("foo2", CEPH_NOSNAP)));
for (unsigned i = 0; i < 1000; ++i) {
tester.set_key(hoid, "foo" + num_str(i), "bar" + num_str(i));
}
db->clone(hoid, hoid2);
int r = 0;
for (unsigned i = 0; i < 1000; ++i) {
string result;
r = tester.get_key(hoid, "foo" + num_str(i), &result);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
r = tester.get_key(hoid2, "foo" + num_str(i), &result);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
if (i % 2) {
tester.remove_key(hoid, "foo" + num_str(i));
} else {
tester.remove_key(hoid2, "foo" + num_str(i));
}
}
for (unsigned i = 0; i < 1000; ++i) {
string result;
string result2;
r = tester.get_key(hoid, "foo" + num_str(i), &result);
int r2 = tester.get_key(hoid2, "foo" + num_str(i), &result2);
if (i % 2) {
ASSERT_EQ(0, r);
ASSERT_EQ(1, r2);
ASSERT_EQ("bar" + num_str(i), result2);
} else {
ASSERT_EQ(0, r2);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
}
}
{
ObjectMap::ObjectMapIterator iter = db->get_iterator(hoid);
iter->seek_to_first();
for (unsigned i = 0; i < 1000; ++i) {
if (!(i % 2)) {
ASSERT_TRUE(iter->valid());
ASSERT_EQ("foo" + num_str(i), iter->key());
iter->next();
}
}
}
{
ObjectMap::ObjectMapIterator iter2 = db->get_iterator(hoid2);
iter2->seek_to_first();
for (unsigned i = 0; i < 1000; ++i) {
if (i % 2) {
ASSERT_TRUE(iter2->valid());
ASSERT_EQ("foo" + num_str(i), iter2->key());
iter2->next();
}
}
}
db->clear(hoid);
db->clear(hoid2);
}
TEST_F(ObjectMapTest, Rename) {
ghobject_t hoid(hobject_t(sobject_t("foo", CEPH_NOSNAP)));
ghobject_t hoid2(hobject_t(sobject_t("foo2", CEPH_NOSNAP)));
for (unsigned i = 0; i < 1000; ++i) {
tester.set_key(hoid, "foo" + num_str(i), "bar" + num_str(i));
}
db->rename(hoid, hoid2);
// Verify rename where target exists
db->clone(hoid2, hoid);
db->rename(hoid, hoid2);
int r = 0;
for (unsigned i = 0; i < 1000; ++i) {
string result;
r = tester.get_key(hoid2, "foo" + num_str(i), &result);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
if (i % 2) {
tester.remove_key(hoid2, "foo" + num_str(i));
}
}
for (unsigned i = 0; i < 1000; ++i) {
string result;
r = tester.get_key(hoid2, "foo" + num_str(i), &result);
if (i % 2) {
ASSERT_EQ(0, r);
} else {
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
}
}
{
ObjectMap::ObjectMapIterator iter = db->get_iterator(hoid2);
iter->seek_to_first();
for (unsigned i = 0; i < 1000; ++i) {
if (!(i % 2)) {
ASSERT_TRUE(iter->valid());
ASSERT_EQ("foo" + num_str(i), iter->key());
iter->next();
}
}
}
db->clear(hoid2);
}
TEST_F(ObjectMapTest, OddEvenOldClone) {
ghobject_t hoid(hobject_t(sobject_t("foo", CEPH_NOSNAP)));
ghobject_t hoid2(hobject_t(sobject_t("foo2", CEPH_NOSNAP)));
for (unsigned i = 0; i < 1000; ++i) {
tester.set_key(hoid, "foo" + num_str(i), "bar" + num_str(i));
}
db->legacy_clone(hoid, hoid2);
int r = 0;
for (unsigned i = 0; i < 1000; ++i) {
string result;
r = tester.get_key(hoid, "foo" + num_str(i), &result);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
r = tester.get_key(hoid2, "foo" + num_str(i), &result);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
if (i % 2) {
tester.remove_key(hoid, "foo" + num_str(i));
} else {
tester.remove_key(hoid2, "foo" + num_str(i));
}
}
for (unsigned i = 0; i < 1000; ++i) {
string result;
string result2;
r = tester.get_key(hoid, "foo" + num_str(i), &result);
int r2 = tester.get_key(hoid2, "foo" + num_str(i), &result2);
if (i % 2) {
ASSERT_EQ(0, r);
ASSERT_EQ(1, r2);
ASSERT_EQ("bar" + num_str(i), result2);
} else {
ASSERT_EQ(0, r2);
ASSERT_EQ(1, r);
ASSERT_EQ("bar" + num_str(i), result);
}
}
{
ObjectMap::ObjectMapIterator iter = db->get_iterator(hoid);
iter->seek_to_first();
for (unsigned i = 0; i < 1000; ++i) {
if (!(i % 2)) {
ASSERT_TRUE(iter->valid());
ASSERT_EQ("foo" + num_str(i), iter->key());
iter->next();
}
}
}
{
ObjectMap::ObjectMapIterator iter2 = db->get_iterator(hoid2);
iter2->seek_to_first();
for (unsigned i = 0; i < 1000; ++i) {
if (i % 2) {
ASSERT_TRUE(iter2->valid());
ASSERT_EQ("foo" + num_str(i), iter2->key());
iter2->next();
}
}
}
db->clear(hoid);
db->clear(hoid2);
}
TEST_F(ObjectMapTest, RandomTest) {
tester.def_init();
for (unsigned i = 0; i < 5000; ++i) {
unsigned val = rand();
val <<= 8;
val %= 100;
if (!(i%100))
std::cout << "on op " << i
<< " val is " << val << std::endl;
if (val < 7) {
tester.auto_write_header(std::cerr);
} else if (val < 14) {
ASSERT_TRUE(tester.auto_verify_header(std::cerr));
} else if (val < 30) {
tester.auto_set_keys(std::cerr);
} else if (val < 42) {
tester.auto_set_xattr(std::cerr);
} else if (val < 55) {
ASSERT_TRUE(tester.auto_check_present_key(std::cerr));
} else if (val < 62) {
ASSERT_TRUE(tester.auto_check_present_xattr(std::cerr));
} else if (val < 70) {
ASSERT_TRUE(tester.auto_check_absent_key(std::cerr));
} else if (val < 72) {
ASSERT_TRUE(tester.auto_check_absent_xattr(std::cerr));
} else if (val < 73) {
tester.auto_clear_omap(std::cerr);
} else if (val < 76) {
tester.auto_delete_object(std::cerr);
} else if (val < 85) {
tester.auto_clone_key(std::cerr);
} else if (val < 92) {
tester.auto_remove_xattr(std::cerr);
} else {
tester.auto_remove_keys(std::cerr);
}
if (i % 500) {
tester.auto_verify_objects(std::cerr);
}
}
}
TEST_F(ObjectMapTest, RandomTestNoDeletesXattrs) {
tester.def_init();
for (unsigned i = 0; i < 5000; ++i) {
unsigned val = rand();
val <<= 8;
val %= 100;
if (!(i%100))
std::cout << "on op " << i
<< " val is " << val << std::endl;
if (val < 45) {
tester.auto_set_keys(std::cerr);
} else if (val < 90) {
tester.auto_remove_keys(std::cerr);
} else {
tester.auto_clone_key(std::cerr);
}
if (i % 500) {
tester.auto_verify_objects(std::cerr);
}
}
}
string num_to_key(unsigned i) {
char buf[100];
int ret = snprintf(buf, sizeof(buf), "%010u", i);
ceph_assert(ret > 0);
return string(buf, ret);
}
TEST_F(ObjectMapTest, TestMergeNewCompleteContainBug) {
/* This test exploits a bug in kraken and earlier where merge_new_complete
* could miss complete entries fully contained by a new entry. To get this
* to actually result in an incorrect return value, you need to remove at
* least two values, one before a complete region, and one which occurs in
* the parent after the complete region (but within 20 not yet completed
* parent points of the first value).
*/
for (unsigned i = 10; i < 160; i+=2) {
tester.test_set_key("foo", num_to_key(i), "asdf");
}
tester.test_clone("foo", "foo2", std::cout);
tester.test_clear("foo");
tester.test_set_key("foo2", num_to_key(15), "asdf");
tester.test_set_key("foo2", num_to_key(13), "asdf");
tester.test_set_key("foo2", num_to_key(57), "asdf");
tester.test_remove_key("foo2", num_to_key(15));
set<string> to_remove;
to_remove.insert(num_to_key(13));
to_remove.insert(num_to_key(58));
to_remove.insert(num_to_key(60));
to_remove.insert(num_to_key(62));
tester.test_remove_keys("foo2", to_remove);
tester.verify_keys("foo2", std::cout);
ASSERT_EQ(tester.get_key("foo2", num_to_key(10), nullptr), 1);
ASSERT_EQ(tester.get_key("foo2", num_to_key(1), nullptr), 0);
ASSERT_EQ(tester.get_key("foo2", num_to_key(56), nullptr), 1);
// this one triggers the bug
ASSERT_EQ(tester.get_key("foo2", num_to_key(58), nullptr), 0);
}
TEST_F(ObjectMapTest, TestIterateBug18533) {
/* This test starts with the one immediately above to create a pair of
* complete regions where one contains the other. Then, it deletes the
* key at the start of the contained region. The logic in next_parent()
* skips ahead to the end of the contained region, and we start copying
* values down again from the parent into the child -- including some
* that had actually been deleted. I think this works for any removal
* within the outer complete region after the start of the contained
* region.
*/
for (unsigned i = 10; i < 160; i+=2) {
tester.test_set_key("foo", num_to_key(i), "asdf");
}
tester.test_clone("foo", "foo2", std::cout);
tester.test_clear("foo");
tester.test_set_key("foo2", num_to_key(15), "asdf");
tester.test_set_key("foo2", num_to_key(13), "asdf");
tester.test_set_key("foo2", num_to_key(57), "asdf");
tester.test_set_key("foo2", num_to_key(91), "asdf");
tester.test_remove_key("foo2", num_to_key(15));
set<string> to_remove;
to_remove.insert(num_to_key(13));
to_remove.insert(num_to_key(58));
to_remove.insert(num_to_key(60));
to_remove.insert(num_to_key(62));
to_remove.insert(num_to_key(82));
to_remove.insert(num_to_key(84));
tester.test_remove_keys("foo2", to_remove);
//tester.test_remove_key("foo2", num_to_key(15)); also does the trick
tester.test_remove_key("foo2", num_to_key(80));
// the iterator in verify_keys will return an extra value
tester.verify_keys("foo2", std::cout);
}
| 31,252 | 26.731145 | 82 |
cc
|
null |
ceph-main/src/test/behave_tests/README.md
|
# Integration testing using the behave framework
## Introduction
Behave framework is based on the Behaviour driven development where the test cases defined using gherkin language (written natural language style). The test cases are defined in .feature files in `feature` directory and python implementation defined under `/feature/steps`.
`features/environment.py` file is used to set up environment for testing the scenario using the kcli tool. When behave command is execute before each feature, kcli plan is generated to create the virtual machines.
## Issues
* We can't run the behave test cases via tox command.
## Executing the behave tests
We can execute all test scenario's by executing `behave` command under `src/test/behave_test` where `features` directory is required.
```bash
$ behave
```
## Executing the behave tests with tags
Tag's can be used to execute only specific type of test scenario's.
```bash
$ behave -t <tag_name>
```
We have included the following tag for implemented test cases.
* osd
* ceph_shell
* cephadm
## Steps used to define the test scenarios
Python implementation of steps are defined in `steps` directory under `src/test/behave_tests/features/`.
Following implemented gherkin language steps used in `.feature` files to define the test scenarios.
@given steps
* __I log as root into {`vm_name`}__ (vm_name is name of virtual machine)
* __I execute in {`shell`}__ (shell should defined as `host` or `cephadm_shell`)
@when steps
* __I execute in {`shell`}__
@then steps
* __I execute in {`shell`}__
* __I wait for {`timeout`} seconds until I get__ (timeout should be defined in seconds)
* __I get results which contain__
| 1,675 | 31.862745 | 273 |
md
|
null |
ceph-main/src/test/behave_tests/features/environment.py
|
import logging
import os
import re
from jinja2 import Template
from kcli_handler import is_bootstrap_script_complete, execute_kcli_cmd
KCLI_PLANS_DIR = "generated_plans"
KCLI_PLAN_NAME = "behave_test_plan"
Kcli_Config = {
"nodes": 1,
"pool": "default",
"network": "default",
"domain": "cephlab.com",
"prefix": "ceph",
"numcpus": 1,
"memory": 1024,
"image": "fedora33",
"notify": False,
"admin_password": "password",
"disks": [150, 3],
}
Bootstrap_Config = {
"configure_osd": False
}
def _write_file(file_path, data):
with open(file_path, "w") as file:
file.write(data)
def _read_file(file_path):
file = open(file_path, "r")
data = "".join(file.readlines())
file.close()
return data
def _loaded_templates():
temp_dir = os.path.join(os.getcwd(), "template")
logging.info("Loading templates")
kcli = _read_file(os.path.join(temp_dir, "kcli_plan_template"))
script = _read_file(os.path.join(temp_dir, "bootstrap_script_template"))
return (
Template(kcli),
Template(script)
)
def _clean_generated(dir_path):
logging.info("Deleting generated files")
for file in os.listdir(dir_path):
os.remove(os.path.join(dir_path, file))
os.rmdir(dir_path)
def _parse_value(value):
if value.isnumeric():
return int(value)
if value.endswith("gb"):
return int(value.replace("gb", "")) * 1024
elif value.endswith("mb"):
return value.replace("mb", "")
return value
def _parse_to_config_dict(values, config):
for key in values.keys():
config[key] = _parse_value(values[key])
def _parse_vm_description(specs):
"""
Parse's vm specfication description into configuration dictionary
"""
kcli_config = Kcli_Config.copy()
parsed_str = re.search(
r"(?P<nodes>[\d]+) nodes with (?P<memory>[\w\.-]+) ram",
specs.lower(),
)
if parsed_str:
for spec_key in parsed_str.groupdict().keys():
kcli_config[spec_key] = _parse_value(parsed_str.group(spec_key))
parsed_str = re.search(r"(?P<numcpus>[\d]+) cpus", specs.lower())
if parsed_str:
kcli_config["numcpus"] = parsed_str.group("numcpus")
parsed_str = re.search(
r"(?P<disk>[\d]+) storage devices of (?P<volume>[\w\.-]+)Gb each",
specs,
)
if parsed_str:
kcli_config["disks"] = [
_parse_value(parsed_str.group("volume"))
] * _parse_value(parsed_str.group("disk"))
parsed_str = re.search(r"(?P<image>[\w\.-]+) image", specs.lower())
if parsed_str:
kcli_config["image"] = parsed_str.group("image")
return kcli_config
def _parse_ceph_description(specs):
"""
Parse the ceph boostrap script configuration descriptions.
"""
bootstrap_script_config = Bootstrap_Config.copy()
parsed_str = re.search(
r"OSD (?P<osd>[\w\.-]+)", specs
)
if parsed_str:
bootstrap_script_config["configure_osd"] = True if _parse_value(
parsed_str.group("osd")
) else False
return bootstrap_script_config
def _handle_kcli_plan(command_type, plan_file_path=None):
"""
Executes the kcli vm create and delete command according
to the provided configuration.
"""
op = None
if command_type == "create":
# TODO : Before creating kcli plan check for exisitng kcli plans
op, code = execute_kcli_cmd(
f"create plan -f {plan_file_path} {KCLI_PLAN_NAME}"
)
if code:
print(f"Failed to create kcli plan\n Message: {op}")
exit(1)
elif command_type == "delete":
op, code = execute_kcli_cmd(f"delete plan {KCLI_PLAN_NAME} -y")
print(op)
def has_ceph_configuration(descriptions, config_line):
"""
Checks for ceph cluster configuration in descriptions.
"""
index_config = -1
for line in descriptions:
if line.lower().startswith(config_line):
index_config = descriptions.index(line)
if index_config != -1:
return (
descriptions[:index_config],
descriptions[index_config:],
)
return (
descriptions,
None,
)
def before_feature(context, feature):
kcli_plans_dir_path = os.path.join(
os.getcwd(),
KCLI_PLANS_DIR,
)
if not os.path.exists(kcli_plans_dir_path):
os.mkdir(kcli_plans_dir_path)
vm_description, ceph_description = has_ceph_configuration(
feature.description,
"- configure ceph cluster",
)
loaded_kcli, loaded_script = _loaded_templates()
vm_feature_specs = " ".join(
[line for line in vm_description if line.startswith("-")]
)
vm_config = _parse_vm_description("".join(vm_feature_specs))
kcli_plan_path = os.path.join(kcli_plans_dir_path, "gen_kcli_plan.yml")
print(f"Kcli vm configureaton \n {vm_config}")
_write_file(
kcli_plan_path,
loaded_kcli.render(vm_config)
)
# Checks for ceph description if None set the default configurations
ceph_config = _parse_ceph_description(
"".join(ceph_description)
) if ceph_description else Bootstrap_Config
print(f"Bootstrap configuraton \n {ceph_config}\n")
_write_file(
os.path.join(kcli_plans_dir_path, "bootstrap_cluster_dev.sh"),
loaded_script.render(ceph_config),
)
_handle_kcli_plan("create", os.path.relpath(kcli_plan_path))
if not is_bootstrap_script_complete():
print("Failed to complete bootstrap..")
_handle_kcli_plan("delete")
exit(1)
context.last_executed = {}
def after_feature(context, feature):
if os.path.exists(KCLI_PLANS_DIR):
_clean_generated(os.path.abspath(KCLI_PLANS_DIR))
_handle_kcli_plan("delete")
| 5,810 | 26.9375 | 76 |
py
|
null |
ceph-main/src/test/behave_tests/features/kcli_handler.py
|
import subprocess
import time
import os
kcli_exec = r"""
podman run --net host -it --rm --security-opt label=disable
-v $HOME/.ssh:/root/.ssh -v $HOME/.kcli:/root/.kcli
-v /var/lib/libvirt/images:/var/lib/libvirt/images
-v /var/run/libvirt:/var/run/libvirt -v $PWD:/workdir
-v /var/tmp:/ignitiondir jolmomar/kcli
"""
def _create_kcli_cmd(command):
cmd = kcli_exec.replace("$HOME", os.getenv("HOME"))
cmd = cmd.replace("$PWD", os.getenv("PWD"))
kcli = cmd.replace("\n", "").split(" ")
return kcli + command.split(" ")
def is_bootstrap_script_complete():
"""
Checks for status of bootstrap script executions.
"""
timeout = 0
command = " ".join(
[
f'"{cmd}"' for cmd in
"journalctl --no-tail --no-pager -t cloud-init".split(" ")
]
)
cmd = _create_kcli_cmd(
f'ssh ceph-node-00 {command} | grep "Bootstrap complete."'
)
while timeout < 10: # Totally waits for 5 mins before giving up
proc = subprocess.run(cmd, capture_output=True, text=True)
if "Bootstrap complete." in proc.stdout:
print("Bootstrap script completed successfully")
return True
timeout += 1
print("Waiting for bootstrap_cluster script...")
print(proc.stdout[len(proc.stdout) - 240:])
time.sleep(30)
print(
f"Timeout reached {30*timeout}. Giving up for boostrap to complete"
)
return False
def execute_kcli_cmd(command):
"""
Executes the kcli command by combining the provided command
with kcli executable command.
"""
cmd = _create_kcli_cmd(command)
print(f"Executing kcli command : {command}")
try:
proc = subprocess.run(
cmd,
capture_output=True,
text=True,
# env=dict(STORAGE_OPTS=''),
)
except Exception as ex:
print(f"Error executing kcli command\n{ex}")
op = proc.stderr if proc.stderr else proc.stdout
return (op, proc.returncode)
def execute_ssh_cmd(vm_name, shell, command):
"""
Executes the provided ssh command on the provided vm machine
"""
if shell == "cephadm_shell":
command = f"cephadm shell {command}"
sudo_cmd = f"sudo -i {command}".split(" ")
sudo_cmd = " ".join([f'"{cmd}"' for cmd in sudo_cmd])
cmd = _create_kcli_cmd(f"ssh {vm_name} {sudo_cmd}")
print(f"Executing ssh command : {cmd}")
try:
proc = subprocess.run(cmd, capture_output=True, text=True)
except Exception as ex:
print(f"Error executing ssh command: {ex}")
op = proc.stderr if proc.stderr else proc.stdout
return (op, proc.returncode)
| 2,673 | 29.044944 | 75 |
py
|
null |
ceph-main/src/test/behave_tests/features/validation_util.py
|
def str_to_list(string):
"""
Converts the string into list removing whitespaces
"""
string = string.replace('\t', '\n')
return [
[
key for key in line.split(' ')
if key != ''
]
for line in string.split('\n')
if line != ''
]
def assert_str_in_list(keyword_list, output_list):
for keyword in keyword_list:
assert keyword in output_list, f" Not found {keyword}"
| 454 | 21.75 | 62 |
py
|
null |
ceph-main/src/test/behave_tests/features/steps/ceph_steps.py
|
import time
from behave import given, when, then
from kcli_handler import execute_ssh_cmd
from validation_util import str_to_list
@given("I log as root into {node}")
def login_to_node(context, node):
context.node = node
@given("I execute in {shell}")
def init_step_execute(context, shell):
commands = context.text.split("\n")
for command in commands:
op, code = execute_ssh_cmd(context.node, shell, command)
if code:
raise Exception("Failed to execute")
context.last_executed["cmd"] = command
context.last_executed["shell"] = shell
@when("I execute in {shell}")
@then("I execute in {shell}")
def execute_step(context, shell):
if context.node is None:
raise Exception("Failed not logged into virtual machine")
for command in context.text.split("\n"):
output, return_code = execute_ssh_cmd(context.node, shell, command)
context.last_executed["cmd"] = command
context.last_executed["shell"] = shell
if return_code != 0:
raise Exception(f"Failed to execute ssh\n Message:{output}")
context.output = str_to_list(output)
print(f"Executed output : {context.output}")
@then("Execute in {shell} only {command}")
def execute_only_one_step(context, shell, command):
"""
Run's single command and doesn't use multi-line
:params command: given command to execute
"""
if context.node is None:
raise Exception("Failed not logged into virtual machine")
output, return_code = execute_ssh_cmd(context.node, shell, command)
context.last_executed["cmd"] = command
context.last_executed["shell"] = shell
if return_code != 0:
raise Exception(f"Failed to execute ssh\nMessage:{output}")
context.output = str_to_list(output)
print(f"Executed output : {context.output}")
@then("I wait for {time_out:n} seconds until I get")
def execute_and_wait_until_step(context, time_out):
wait_time = int(time_out/4)
context.found_all_keywords = False
if context.node is None:
raise Exception("Failed not logged into virtual machine")
exec_shell = context.last_executed['shell']
exec_cmd = context.last_executed['cmd']
if exec_shell is None and exec_cmd is None:
raise Exception("Last executed command not found..")
expected_output = str_to_list(context.text)
while wait_time < time_out and not context.found_all_keywords:
found_keys = []
context.execute_steps(
f"then Execute in {exec_shell} only {exec_cmd}"
)
executed_output = context.output
for expected_line in expected_output:
for op_line in executed_output:
if set(expected_line).issubset(set(op_line)):
found_keys.append(" ".join(expected_line))
if len(found_keys) != len(expected_output):
print(f"Waiting for {int(time_out/4)} seconds")
time.sleep(int(time_out/4))
wait_time += int(time_out/4)
else:
print("Found all expected keywords")
context.found_all_keywords = True
break
if not context.found_all_keywords:
print(
f"Timeout reached {time_out}. Giving up on waiting for keywords"
)
@then("I get results which contain")
def validation_step(context):
expected_keywords = str_to_list(context.text)
output_lines = context.output
for keys_line in expected_keywords:
found_keyword = False
for op_line in output_lines:
if set(keys_line).issubset(set(op_line)):
found_keyword = True
output_lines.remove(op_line)
if not found_keyword:
assert False, f"Not found {keys_line}"
| 3,754 | 34.093458 | 76 |
py
|
null |
ceph-main/src/test/centos-8/install-deps.sh
|
../../../install-deps.sh
| 24 | 24 | 24 |
sh
|
null |
ceph-main/src/test/ceph-erasure-code-tool/test_ceph-erasure-code-tool.sh
|
#!/bin/sh -ex
TMPDIR=/tmp/test_ceph-erasure-code-tool.$$
mkdir $TMPDIR
trap "rm -fr $TMPDIR" 0
ceph-erasure-code-tool test-plugin-exists INVALID_PLUGIN && exit 1
ceph-erasure-code-tool test-plugin-exists jerasure
ceph-erasure-code-tool validate-profile \
plugin=jerasure,technique=reed_sol_van,k=2,m=1
test "$(ceph-erasure-code-tool validate-profile \
plugin=jerasure,technique=reed_sol_van,k=2,m=1 chunk_count)" = 3
test "$(ceph-erasure-code-tool calc-chunk-size \
plugin=jerasure,technique=reed_sol_van,k=2,m=1 4194304)" = 2097152
dd if="$(which ceph-erasure-code-tool)" of=$TMPDIR/data bs=770808 count=1
cp $TMPDIR/data $TMPDIR/data.orig
ceph-erasure-code-tool encode \
plugin=jerasure,technique=reed_sol_van,k=2,m=1 \
4096 \
0,1,2 \
$TMPDIR/data
test -f $TMPDIR/data.0
test -f $TMPDIR/data.1
test -f $TMPDIR/data.2
rm $TMPDIR/data
ceph-erasure-code-tool decode \
plugin=jerasure,technique=reed_sol_van,k=2,m=1 \
4096 \
0,2 \
$TMPDIR/data
size=$(stat -c '%s' $TMPDIR/data.orig)
truncate -s "${size}" $TMPDIR/data # remove stripe width padding
cmp $TMPDIR/data.orig $TMPDIR/data
echo OK
| 1,327 | 29.181818 | 76 |
sh
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.