}
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
foo += ::write(fd[1], &r, sizeof(r));
}
- g_ceph_context->put();
free(newargv);
delete mc;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_MDS, CODE_ENVIRONMENT_DAEMON,
- 0, "mds_data");
+ auto cct = global_init(NULL, args,
+ CEPH_ENTITY_TYPE_MDS, CODE_ENVIRONMENT_DAEMON,
+ 0, "mds_data");
ceph_heap_profiler_init();
std::string val, action;
delete msgr;
}
- g_ceph_context->put();
-
// cd on exit, so that gmon.out (if any) goes into a separate directory for each node.
char s[20];
snprintf(s, sizeof(s), "gmon/%d", getpid());
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_MGR, CODE_ENVIRONMENT_DAEMON, 0,
- "mgr_data");
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_MGR,
+ CODE_ENVIRONMENT_DAEMON, 0,
+ "mgr_data");
// For consumption by KeyRing::from_ceph_context in MonClient
g_conf->set_val("keyring", "$mgr_data/keyring", false);
}
}
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_MON, CODE_ENVIRONMENT_DAEMON, flags, "mon_data");
+ auto cct = global_init(&def_args, args,
+ CEPH_ENTITY_TYPE_MON, CODE_ENVIRONMENT_DAEMON,
+ flags, "mon_data");
ceph_heap_profiler_init();
uuid_d fsid;
delete msgr;
delete client_throttler;
delete daemon_throttler;
- g_ceph_context->put();
// cd on exit, so that gmon.out (if any) goes into a separate directory for each node.
char s[20];
// option, therefore we will pass it as a default argument to global_init().
def_args.push_back("--leveldb-log=");
- global_init(&def_args, args, CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_DAEMON,
- 0, "osd_data");
+ auto cct = global_init(&def_args, args, CEPH_ENTITY_TYPE_OSD,
+ CODE_ENVIRONMENT_DAEMON,
+ 0, "osd_data");
ceph_heap_profiler_init();
// osd specific args
client_byte_throttler.reset();
client_msg_throttler.reset();
- g_ceph_context->put();
// cd on exit, so that gmon.out (if any) goes into a separate directory for each node.
char s[20];
vector<const char*> args;
argv_to_vec(argc, argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
parse_syn_options(args); // for SyntheticClient
g_conf->complain_about_parse_errors(g_ceph_context);
}
-void global_init(std::vector < const char * > *alt_def_args,
- std::vector < const char* >& args,
- uint32_t module_type, code_environment_t code_env,
- int flags,
- const char *data_dir_option, bool run_pre_init)
+boost::intrusive_ptr<CephContext>
+global_init(std::vector < const char * > *alt_def_args,
+ std::vector < const char* >& args,
+ uint32_t module_type, code_environment_t code_env,
+ int flags,
+ const char *data_dir_option, bool run_pre_init)
{
// Ensure we're not calling the global init functions multiple times.
static bool first_run = true;
output_ceph_version();
g_ceph_context->crush_location.init_on_startup();
+
+ return boost::intrusive_ptr<CephContext>{g_ceph_context, false};
+}
+
+void intrusive_ptr_add_ref(CephContext* cct)
+{
+ cct->get();
+}
+
+void intrusive_ptr_release(CephContext* cct)
+{
+ cct->put();
}
void global_print_banner(void)
#include <stdint.h>
#include <vector>
-
+#include <boost/intrusive_ptr.hpp>
+#include "include/assert.h"
#include "common/code_environment.h"
#include "common/common_init.h"
* daemons and utility programs need to call. It takes care of a lot of
* initialization, including setting up g_ceph_context.
*/
-void global_init(std::vector < const char * > *alt_def_args,
+boost::intrusive_ptr<CephContext>
+ global_init(std::vector < const char * > *alt_def_args,
std::vector < const char* >& args,
uint32_t module_type,
code_environment_t code_env,
const char *data_dir_option = 0,
bool run_pre_init = true);
+void intrusive_ptr_add_ref(CephContext* cct);
+void intrusive_ptr_release(CephContext* cct);
+
// just the first half; enough to get config parsed but doesn't start up the
// cct or log.
void global_pre_init(std::vector < const char * > *alt_def_args,
bool opt_version = false;
bool opt_vernum = false;
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ 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);
for (std::vector<const char*>::iterator i = args.begin();
i != args.end(); ) {
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val(
"enable_experimental_unrecoverable_data_corrupting_features",
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
std::vector<const char*>::iterator i;
string pool_name = "rbd";
def_args.push_back("--keyring=$rgw_data/keyring");
def_args.push_back("--log-file=/var/log/radosgw/$cluster-$name.log");
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_CLIENT,
- CODE_ENVIRONMENT_DAEMON,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
+ cct = global_init(&def_args, args,
+ CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
Mutex mutex("main");
SafeTimer init_timer(g_ceph_context, mutex);
rgw_perf_stop(g_ceph_context);
dout(1) << "final shutdown" << dendl;
- g_ceph_context->put();
+ cct.reset();
ceph::crypto::shutdown();
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
rgw_user user_id;
#include <mutex>
#include "include/unordered_map.h"
+#include "global/global_init.h"
#include "rgw_common.h"
#include "rgw_client_io.h"
#include "rgw_rest.h"
rgw::LDAPHelper* ldh;
RGWREST rest; // XXX needed for RGWProcessEnv
RGWRados* store;
+ boost::intrusive_ptr<CephContext> cct;
public:
RGWLib() : fec(nullptr), fe(nullptr), olog(nullptr), store(nullptr)
return mgr;
}
-void intrusive_ptr_add_ref(CephContext* cct) { cct->get(); }
-void intrusive_ptr_release(CephContext* cct) { cct->put(); }
-
RGWRealmReloader *preloader = NULL;
static void reloader_handler(int signum)
// Now that we've determined which frontend(s) to use, continue with global
// initialization. Passing false as the final argument ensures that
// global_pre_init() is not invoked twice.
- global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
- flags, "rgw_data", false);
+ // claim the reference and release it after subsequent destructors have fired
+ auto cct = global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ flags, "rgw_data", false);
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ++i) {
if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
common_init_finish(g_ceph_context);
- // claim the reference and release it after subsequent destructors have fired
- boost::intrusive_ptr<CephContext> cct(g_ceph_context, false);
-
int r = rgw_tools_init(g_ceph_context);
if (r < 0) {
derr << "ERROR: unable to initialize rgw tools" << dendl;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS, "rgw_data");
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS, "rgw_data");
for (std::vector<const char *>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
char *v{nullptr};
vector<const char*> args;
argv_to_vec(argc, (const char **) argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
test_fn_t fn = NULL;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
int ret;
*
*/
-#include <gtest/gtest.h>
-
#include "common/Mutex.h"
#include "common/Cond.h"
#include "common/admin_socket.h"
#include "common/admin_socket_client.h"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include "global/global_context.h"
+#include "test/unit.h"
#include <stdint.h>
#include <string.h>
}
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- vector<const char*> def_args;
- global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd .. ;
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_OSD,
+ CODE_ENVIRONMENT_UTILITY, 0);
utime_t start = ceph_clock_now(NULL);
#include "common/Thread.h"
#include "common/Throttle.h"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include <gtest/gtest.h>
+#include "test/unit.h"
#include <thread>
#include <atomic>
ASSERT_GT(results.second.count(), 0.0005);
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ;
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
if (args.empty()) {
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
const char* env = getenv("CEPH_LIB");
#include "common/Thread.h"
#include "common/shared_cache.hpp"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include <gtest/gtest.h>
+#include "test/unit.h"
class SharedLRUTest : public SharedLRU<unsigned int, int> {
public:
ASSERT_TRUE(cache.lookup(0).get());
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
// Local Variables:
// compile-command: "cd ../.. ; make unittest_shared_cache && ./unittest_shared_cache # --gtest_filter=*.* --log-to-stderr=true"
// End:
#include "common/Thread.h"
#include "common/sharedptr_registry.hpp"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include <gtest/gtest.h>
+#include "test/unit.h"
class SharedPtrRegistryTest : public SharedPtrRegistry<unsigned int, int> {
public:
EXPECT_FALSE(registry.lookup(key));
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
// Local Variables:
// compile-command: "cd ../.. ; make unittest_sharedptr_registry && ./unittest_sharedptr_registry # --gtest_filter=*.* --log-to-stderr=true"
// End:
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
-#include <gtest/gtest.h>
-#include "global/global_init.h"
#include "compressor/Compressor.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "compressor/CompressionPlugin.h"
+#include "test/unit.h"
class CompressorTest : public ::testing::Test,
public ::testing::WithParamInterface<const char*> {
EXPECT_TRUE(exp.contents_equal(after));
}
}
-
-
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- if (env)
- g_conf->set_val("plugin_dir", env, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
vector<const char*> def_args;
def_args.push_back("--debug-crush=0");
- global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
#include <gtest/gtest.h>
#include "include/stringify.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include "global/global_context.h"
#include "crush/CrushWrapper.h"
#include "osd/osd_types.h"
+#include "test/unit.h"
#include <set>
cout << " vs " << estddev << std::endl;
}
}
-
-
-
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
// multiple times simultaneously from different threads.
TEST(CRYPTO_INIT, NSS_RACE) {
std::vector<const char*> args;
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
// Most reliably reproduced with more threads than cores.
long n_thread = sysconf(_SC_NPROCESSORS_ONLN) * 2;
pthread_t *ts = (pthread_t*)malloc(n_thread * sizeof(pthread_t));
#include <errno.h>
#include <stdlib.h>
-#include "global/global_init.h"
#include "erasure-code/ErasureCode.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
class ErasureCodeTest : public ErasureCode {
public:
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ;
#include <stdlib.h>
#include "include/stringify.h"
-#include "global/global_init.h"
#include "ErasureCodeExample.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
TEST(ErasureCodeExample, chunk_size)
{
EXPECT_EQ(0, example.create_ruleset("myrule", *c, &ss));
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ;
#include "crush/CrushWrapper.h"
#include "include/stringify.h"
-#include "global/global_init.h"
#include "erasure-code/isa/ErasureCodeIsa.h"
#include "erasure-code/isa/xor_op.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
ErasureCodeIsaTableCache tcache;
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **) argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 unittest_erasure_code_isa &&
#include "crush/CrushWrapper.h"
#include "include/stringify.h"
-#include "global/global_init.h"
#include "erasure-code/jerasure/ErasureCodeJerasure.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
+
template <typename T>
class ErasureCodeTest : public ::testing::Test {
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ;
#include "crush/CrushWrapper.h"
#include "common/config.h"
#include "include/stringify.h"
-#include "global/global_init.h"
#include "erasure-code/lrc/ErasureCodeLrc.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
+
TEST(ErasureCodeLrc, parse_ruleset)
{
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ;
#include <signal.h>
#include <stdlib.h>
#include "common/Thread.h"
-#include "global/global_init.h"
#include "erasure-code/ErasureCodePlugin.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
+
class ErasureCodePluginRegistryTest : public ::testing::Test {
protected:
}
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
TEST(ErasureCodePlugin, factory)
{
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
#include <errno.h>
#include <stdlib.h>
-#include "global/global_init.h"
#include "erasure-code/ErasureCodePlugin.h"
-#include "common/ceph_argparse.h"
#include "log/Log.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
TEST(ErasureCodePlugin, factory)
{
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- int status = RUN_ALL_TESTS();
- g_ceph_context->_log->stop();
- return status;
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
#include <stdlib.h>
#include "arch/probe.h"
#include "arch/intel.h"
-#include "global/global_init.h"
#include "erasure-code/ErasureCodePlugin.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
+
TEST(ErasureCodePlugin, factory)
{
EXPECT_TRUE(erasure_code.get());
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
#include <errno.h>
#include <stdlib.h>
-#include "global/global_init.h"
#include "erasure-code/ErasureCodePlugin.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "common/config.h"
-#include "gtest/gtest.h"
+#include "test/unit.h"
TEST(ErasureCodePlugin, factory)
{
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
void* thread1(void* pParam);
void* thread2(void* pParam);
delete profile;
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **) argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
void* thread1(void* pParam)
{
ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
vector<const char*> args;
argv_to_vec(argc, (const char **) argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
const char* env = getenv("CEPH_LIB");
vector<const char*> args;
argv_to_vec(argc, (const char **) argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
const char* env = getenv("CEPH_LIB");
#include "crush/CrushWrapper.h"
#include "osd/osd_types.h"
#include "include/stringify.h"
-#include "global/global_init.h"
#include "erasure-code/shec/ErasureCodeShec.h"
#include "erasure-code/ErasureCodePlugin.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
void* thread1(void* pParam);
pthread_join(tid5, NULL);
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **) argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- const char* env = getenv("CEPH_LIB");
- std::string directory(env ? env : ".libs");
- g_conf->set_val("erasure_code_dir", directory, false, false);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
void* thread1(void* pParam)
{
TestParam* param = static_cast<TestParam*>(pParam);
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
string base;
string directory;
ErasureCodeProfile profile;
+ boost::intrusive_ptr<CephContext> cct;
public:
int setup(int argc, char** argv);
int run();
ceph_options.push_back(i->c_str());
}
- global_init(
- &def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
- CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ cct = global_init(&def_args, ceph_options, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
const char* env = getenv("CEPH_LIB");
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val("osd_journal_size", "100");
g_ceph_context->_conf->apply_changes(NULL);
#include "include/assert.h" // fio.h clobbers our assert.h
-
-// enable boost::intrusive_ptr<CephContext>
-void intrusive_ptr_add_ref(CephContext* cct) { cct->get(); }
-void intrusive_ptr_release(CephContext* cct) { cct->put(); }
-
namespace {
/// fio configuration options read from the job file
args.emplace_back(td->o.directory);
}
- global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
// claim the g_ceph_context reference and release it on destruction
- cct = boost::intrusive_ptr<CephContext>(g_ceph_context, false);
+ auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
+ CODE_ENVIRONMENT_UTILITY, 0);
+ common_init_finish(g_ceph_context);
// create the ObjectStore
os.reset(ObjectStore::create(g_ceph_context,
std::vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
g_conf->set_val("lockdep", "true");
common_init_finish(g_ceph_context);
int r = RUN_ALL_TESTS();
- g_ceph_context->put();
return r;
}
#include "test/librados/test.h"
#include "test/librados/TestCase.h"
#include "global/global_context.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
-#include "common/common_init.h"
+#include "test/unit.h"
#include "include/types.h"
#include "common/hobject.h"
#pragma GCC diagnostic pop
#pragma GCC diagnostic warning "-Wpragmas"
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
- cout << args << std::endl;
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
#include "include/rados/librados.hpp"
#include "include/stringify.h"
#include "global/global_context.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
#include "common/common_init.h"
#include "test/librados/test.h"
#include "test/librados/TestCase.h"
#include <map>
#include <sstream>
#include <string>
+#include "test/unit.h"
+
using namespace librados;
using std::map;
/* write_len = data_len, i.e. same as rados_write() */
ASSERT_EQ(0, rados_writesame(ioctx, "ws", buf, sizeof(buf), sizeof(buf), 0));
}
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
#include "include/stringify.h"
#include "include/types.h"
#include "global/global_context.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
-#include "common/common_init.h"
#include "common/Cond.h"
#include "test/librados/test.h"
#include "test/librados/TestCase.h"
#include "json_spirit/json_spirit.h"
+#include "test/unit.h"
#include "osd/HitSet.h"
// wait for maps to settle before next test
cluster.wait_for_latest_osdmap();
}
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args),
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
#include "include/stringify.h"
#include "mds/MDSAuthCaps.h"
-#include "common/ceph_argparse.h"
-#include "common/common_init.h"
-#include "global/global_init.h"
+#include "test/unit.h"
#include "gtest/gtest.h"
ASSERT_EQ(test_values[i].output, stringify(cap));
}
}
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args, NULL);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
#include "include/stringify.h"
#include "mds/SessionMap.h"
-#include "common/ceph_argparse.h"
-#include "common/common_init.h"
-#include "global/global_init.h"
+#include "test/unit.h"
#include "gtest/gtest.h"
ASSERT_FALSE(filter.match(*a, [](client_t c) -> bool {return false;}));
a->put();
}
-
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_ANY, CODE_ENVIRONMENT_UTILITY,
- 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_ANY,
+ CODE_ENVIRONMENT_UTILITY,
+ 0);
for (arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--addr",
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_ANY, CODE_ENVIRONMENT_DAEMON,
- 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_ANY,
+ CODE_ENVIRONMENT_DAEMON,
+ 0);
for (arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--addr",
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args,
- CEPH_ENTITY_TYPE_ANY, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args,
+ CEPH_ENTITY_TYPE_ANY,
+ CODE_ENVIRONMENT_UTILITY, 0);
for (arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--addr",
#include "mon/PGMap.h"
#include "gtest/gtest.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include "global/global_context.h"
#include "include/stringify.h"
+#include "test/unit.h"
TEST(pgmap, min_last_epoch_clean)
{
ASSERT_EQ(stringify(si_t(avail)), tbl.get(0, col++));
ASSERT_EQ(stringify(0), tbl.get(0, col++));
}
-
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
-
- vector<const char*> def_args;
- global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
int main(int argc, char *argv[])
{
- vector<const char*> def_args;
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- 0);
+ auto cct = global_init(nullptr, args,
+ CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
+ 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
::testing::InitGoogleTest(&argc, argv);
our_name = argv[0];
argv_to_vec(argc, argv, args);
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_UTILITY,
- 0);
+ auto cct = global_init(&def_args, args,
+ CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_UTILITY,
+ 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
#include "msg/async/EventKqueue.h"
#endif
#include "msg/async/EventSelect.h"
+#include "test/unit.h"
#include <gtest/gtest.h>
+
#if GTEST_HAS_PARAM_TEST
class EventDriverTest : public ::testing::TestWithParam<const char*> {
#endif
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make ceph_test_async_driver &&
#include "acconfig.h"
#include "include/Context.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
#include "msg/async/Event.h"
#include "msg/async/Stack.h"
+#include "test/unit.h"
+
#if GTEST_HAS_PARAM_TEST
#endif
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make ceph_test_async_networkstack &&
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
g_ceph_context->_conf->set_val("auth_cluster_required", "none");
g_ceph_context->_conf->set_val("auth_service_required", "none");
g_ceph_context->_conf->set_val("auth_client_required", "none");
#include <random>
#include <gtest/gtest.h>
-#include "common/ceph_argparse.h"
-#include "common/common_init.h"
#include "msg/async/dpdk/UserspaceEvent.h"
#include "global/global_context.h"
-#include "global/global_init.h"
+#include "test/unit.h"
class UserspaceManagerTest : public ::testing::Test {
public:
}
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
* compile-command: "cd ../.. ; make ceph_test_userspace_event &&
* In memory space allocator test cases.
* Author: Ramesh Chander, Ramesh.Chander@sandisk.com
*/
-#include "os/bluestore/Allocator.h"
-#include "global/global_init.h"
#include <iostream>
-#include "include/Context.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
+#include <gtest/gtest.h>
+
#include "common/Mutex.h"
#include "common/Cond.h"
#include "common/errno.h"
#include "include/stringify.h"
-#include <gtest/gtest.h>
-#include <os/bluestore/BitAllocator.h>
+#include "include/Context.h"
+#include "os/bluestore/Allocator.h"
+#include "os/bluestore/BitAllocator.h"
+#include "test/unit.h"
+
#if GTEST_HAS_PARAM_TEST
TEST(DummyTest, ValueParameterizedTestsAreNotSupportedOnThisPlatform) {}
#endif
-
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
#include "include/Context.h"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
#include "os/bluestore/BitAllocator.h"
+#include "test/unit.h"
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include <sstream>
#include <gtest/gtest.h>
+
#define bmap_test_assert(x) ASSERT_EQ(true, (x))
#define NUM_THREADS 16
#define MAX_BLOCKS (1024 * 1024 * 1)
}
}
-
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- int r = RUN_ALL_TESTS();
- g_ceph_context->put();
- return r;
-}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
Cycles::init();
#include <gtest/gtest.h>
#include "include/Context.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
#include "rocksdb/db.h"
#include "rocksdb/env.h"
#include "rocksdb/thread_status.h"
#include "kv/RocksDBStore.h"
+#include "test/unit.h"
#include <iostream>
+
using namespace std;
const string dir("rocksdb.test_temp_dir");
//high pri threads is flusher_threads
ASSERT_EQ(5, num_high_pri_threads);
}
-
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val("err_to_stderr", "false");
g_ceph_context->_conf->set_val("log_to_stderr", "false");
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val("osd_journal_size", "400");
g_ceph_context->_conf->apply_changes(NULL);
::testing::InitGoogleTest(&argc, argv);
- int r = RUN_ALL_TESTS();
- g_ceph_context->put();
- return r;
+ return RUN_ALL_TESTS();
}
/*
def_args.push_back("--debug-bluefs=1/20");
def_args.push_back("--debug-bdev=1/20");
- global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- 0);
+ auto cct = global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val(
"enable_experimental_unrecoverable_data_corrupting_features",
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
- int r = RUN_ALL_TESTS();
- g_ceph_context->put();
- return r;
+ return RUN_ALL_TESTS();
}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
our_name = argv[0];
argv_to_vec(argc, argv, args);
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(&def_args, args,
+ CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->set_val(
"enable_experimental_unrecoverable_data_corrupting_features",
ASSERT_EQ(expected, result);
}
-// enable boost::intrusive_ptr<CephContext>
-void intrusive_ptr_add_ref(CephContext *cct) { cct->get(); }
-void intrusive_ptr_release(CephContext *cct) { cct->put(); }
-
int main(int argc, char** argv)
{
// default to memstore
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
- CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
- // release g_ceph_context on exit
- boost::intrusive_ptr<CephContext> cct{g_ceph_context, false};
-
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
// def_args.push_back("workload_gen_dir/journal");
argv_to_vec(argc, argv, args);
- global_init(&def_args, args,
- CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(&def_args, args,
+ CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_ceph_context->_conf->apply_changes(NULL);
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
+ CODE_ENVIRONMENT_UTILITY, 0);
std::string val;
vector<const char*>::iterator i = args.begin();
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
using namespace std;
int main(int argc, char **argv) {
- std::vector<const char *> preargs;
std::vector<const char*> args(argv, argv+argc);
- global_init(&preargs, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ 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);
// make sure we have 3 copies, or some tests won't work
g_ceph_context->_conf->set_val("osd_pool_default_size", "3", false);
#include <stdio.h>
#include <signal.h>
+#include <gtest/gtest.h>
#include "osd/OSD.h"
#include "os/ObjectStore.h"
#include "mon/MonClient.h"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include <gtest/gtest.h>
#include "msg/Messenger.h"
+#include "test/unit.h"
class TestOSDScrub: public OSD {
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
// Local Variables:
// compile-command: "cd ../.. ; make unittest_osdscrub ; ./unittest_osdscrub --log-to-stderr=true --debug-osd=20 # --gtest_filter=*.* "
// End:
#include <signal.h>
#include "osd/PGLog.h"
#include "osd/OSDMap.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include <gtest/gtest.h>
+#include "test/unit.h"
class PGLogTest : public ::testing::Test, protected PGLog {
public:
EXPECT_EQ(del.reqid, entry->reqid);
}
-int main(int argc, char **argv) {
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
// Local Variables:
// compile-command: "cd ../.. ; make unittest_pglog ; ./unittest_pglog --log-to-stderr=true --debug-osd=20 # --gtest_filter=*.* "
// End:
std::vector<const char*> args;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
long long delay_ns = 0;
long long num_ops = 1000;
preargs.push_back("--admin-socket");
preargs.push_back(get_rand_socket_path());
std::vector<const char*> args;
- global_init(&preargs, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(&preargs, 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();
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
Cycles::init();
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
for (auto i = args.begin(); i != args.end(); ++i) {
if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
int r = rados.init_with_context(g_ceph_context);
if (r < 0) {
derr << "could not initialize RADOS handle" << dendl;
- goto cleanup;
+ return EXIT_FAILURE;
}
r = rados.connect();
if (r < 0) {
derr << "error connecting to local cluster" << dendl;
- goto cleanup;
+ return EXIT_FAILURE;
}
r = rados.ioctx_create(pool_name.c_str(), io_ctx);
if (r < 0) {
derr << "error finding local pool " << pool_name << ": "
<< cpp_strerror(r) << dendl;
- goto cleanup;
+ return EXIT_FAILURE;
}
r = rbd.open(io_ctx, image, image_name.c_str());
if (r < 0) {
derr << "error opening image " << image_name << ": "
<< cpp_strerror(r) << dendl;
- goto cleanup;
+ return EXIT_FAILURE;
}
write_image(image);
-
- cleanup:
- g_ceph_context->put();
-
- return r < 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+ return EXIT_SUCCESS;
}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
curl_global_init(CURL_GLOBAL_ALL);
#include "gtest/gtest.h"
#include "rgw/rgw_compression.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
-
+#include "test/unit.h"
struct MockGetDataCB : public RGWGetDataCB {
int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
ASSERT_EQ(range_t(12, 24), fixup_range(&decompress, 16, 999));
ASSERT_EQ(range_t(18, 24), fixup_range(&decompress, 998, 999));
}
-
-// initialize a CephContext
-int main(int argc, char** argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
#include "arch/probe.h"
#include "arch/intel.h"
#include "arch/arm.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
+#include "test/unit.h"
+
#define FLAGS_SIZE 4096
#endif
}
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
-
/*
* Local Variables:
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_test = new test_cors_helper();
finisher = new Finisher(g_ceph_context);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
char mb[10];
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
// enable debug mode for the tests
vector<const char*> args;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
string val;
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_test = new admin_log::test_helper();
finisher = new Finisher(g_ceph_context);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
g_test = new admin_meta::test_helper();
finisher = new Finisher(g_ceph_context);
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
store = RGWStoreManager::get_storage(g_ceph_context, false, false, false, false);
g_test = new admin_log::test_helper();
#include <set>
#include <boost/scoped_ptr.hpp>
#include <sys/types.h>
+#include <cstdlib>
#include "include/buffer.h"
#include "common/map_cacher.hpp"
#include "osd/SnapMapper.h"
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
+#include "test/unit.h"
#include "gtest/gtest.h"
-#include "stdlib.h"
using namespace std;
init(50);
run();
}
-
-int main(int argc, char **argv)
-{
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
#include "gtest/gtest.h"
#include "global/global_context.h"
-#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include "common/common_init.h"
+#include "test/unit.h"
#include "osdc/Striper.h"
numobjs = Striper::get_num_objects(l, size);
ASSERT_EQ(6u, numobjs);
}
-
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
- env_to_vec(args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
// args
#include "gtest/gtest.h"
#include "common/WorkQueue.h"
-#include "global/global_context.h"
#include "common/ceph_argparse.h"
-#include "global/global_init.h"
-#include "common/common_init.h"
+#include "test/unit.h"
TEST(WorkQueue, StartStop)
{
sleep(1);
tp.stop();
}
-
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
-
- vector<const char*> args;
- argv_to_vec(argc, (const char **)argv, args);
-
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(g_ceph_context);
-
- return RUN_ALL_TESTS();
-}
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
KeyRing extra;
KeyServer server(g_ceph_context, &extra);
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
dout(0) << "i am mon " << args[0] << dendl;
#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
* initialization for you.
*/
int main(int argc, char **argv) {
- std::vector<const char*> args;
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ std::vector<const char*> args(argv, argv + argc);
+ env_to_vec(args);
+ auto cct = global_init(NULL, args,
+ CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
+
+ const char* env = getenv("CEPH_LIB");
+ if (env) {
+ g_conf->set_val("erasure_code_dir", env, false, false);
+ g_conf->set_val("plugin_dir", env, false, false);
+ }
+
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
- global_init(0, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(0, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
std::cerr << "args: " << args << std::endl;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
common_init_finish(g_ceph_context);
map<string,bufferlist> caps;
std::string fn;
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
bool gen_key = false;
bool gen_print_key = false;
global_pre_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
CINIT_FLAG_NO_DAEMON_ACTIONS);
+ std::unique_ptr<CephContext,
+ std::function<void(CephContext*)> > cct_deleter{
+ g_ceph_context,
+ [](CephContext *p) {p->put();}
+ };
+
g_conf->apply_changes(NULL);
g_conf->complain_about_parse_errors(g_ceph_context);
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(
+ auto cct = global_init(
NULL, args,
CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_MON,
CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
return 0;
}
-void myexit(int ret)
-{
- if (g_ceph_context)
- g_ceph_context->put();
- exit(ret);
-}
-
int get_log(ObjectStore *fs, __u8 struct_ver,
coll_t coll, spg_t pgid, const pg_info_t &info,
PGLog::IndexedLog &log, pg_missing_t &missing)
po::include_positional);
} catch(po::error &e) {
std::cerr << e.what() << std::endl;
- myexit(1);
+ return 1;
}
if (vm.count("help")) {
usage(desc);
- myexit(1);
+ return 1;
}
if (!vm.count("debug")) {
!(op == "dump-journal" && type == "filestore")) {
cerr << "Must provide --data-path" << std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
if (type == "filestore" && !vm.count("journal-path")) {
jpath = dpath + "/journal";
if (!vm.count("op") && !vm.count("object")) {
cerr << "Must provide --op or object command..." << std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
if (op != "list" &&
vm.count("op") && vm.count("object")) {
cerr << "Can't specify both --op and object command syntax" << std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
if (op == "apply-layout-settings" && !(vm.count("pool") ^ vm.count("pgid"))) {
cerr << "apply-layout-settings requires either --pool or --pgid"
<< std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
if (op != "list" && vm.count("object") && !vm.count("objcmd")) {
cerr << "Invalid syntax, missing command" << std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
if (op == "fuse" && mountpoint.length() == 0) {
cerr << "Missing fuse mountpoint" << std::endl;
usage(desc);
- myexit(1);
+ return 1;
}
outistty = isatty(STDOUT_FILENO);
if (!vm.count("file") || file == "-") {
if (outistty) {
cerr << "stdout is a tty and no --file filename specified" << std::endl;
- myexit(1);
+ return 1;
}
file_fd = STDOUT_FILENO;
} else {
if (!vm.count("file") || file == "-") {
if (isatty(STDIN_FILENO)) {
cerr << "stdin is a tty and no --file filename specified" << std::endl;
- myexit(1);
+ return 1;
}
file_fd = STDIN_FILENO;
} else {
if (vm.count("file") && file_fd == fd_none && !dry_run) {
cerr << "--file option only applies to import, export, "
<< "get-osdmap, set-osdmap, get-inc-osdmap or set-inc-osdmap" << std::endl;
- myexit(1);
+ return 1;
}
if (file_fd != fd_none && file_fd < 0) {
string err = string("file: ") + file;
perror(err.c_str());
- myexit(1);
+ return 1;
}
- global_init(
+ auto cct = global_init(
NULL, ceph_options, CEPH_ENTITY_TYPE_OSD,
CODE_ENVIRONMENT_UTILITY_NODOUT, 0);
//CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
formatter = Formatter::create(format);
if (formatter == NULL) {
cerr << "unrecognized format: " << format << std::endl;
- myexit(1);
+ return 1;
}
// Special handling for filestore journal, so we can dump it without mounting
if (ret < 0) {
cerr << "journal-path: " << jpath << ": "
<< cpp_strerror(ret) << std::endl;
- myexit(1);
+ return 1;
}
formatter->flush(cout);
- myexit(0);
+ return 0;
}
//Verify that data-path really exists
if (::stat(dpath.c_str(), &st) == -1) {
string err = string("data-path: ") + dpath;
perror(err.c_str());
- myexit(1);
+ return 1;
}
if (pgidstr.length() && !pgid.parse(pgidstr.c_str())) {
cerr << "Invalid pgid '" << pgidstr << "' specified" << std::endl;
- myexit(1);
+ return 1;
}
ObjectStore *fs = ObjectStore::create(g_ceph_context, type, dpath, jpath, flags);
if (fs == NULL) {
cerr << "Unable to create store of type " << type << std::endl;
- myexit(1);
+ return 1;
}
if (op == "fsck" || op == "fsck-deep") {
int r = fs->fsck(op == "fsck-deep");
if (r < 0) {
cerr << "fsck failed: " << cpp_strerror(r) << std::endl;
- myexit(1);
+ return 1;
}
if (r > 0) {
cerr << "fsck found " << r << " errors" << std::endl;
- myexit(1);
+ return 1;
}
cout << "fsck found no errors" << std::endl;
- exit(0);
+ return 0;
}
if (op == "mkfs") {
int r = fs->mkfs();
if (r < 0) {
cerr << "fsck failed: " << cpp_strerror(r) << std::endl;
- myexit(1);
+ return 1;
}
- myexit(0);
+ return 0;
}
ObjectStore::Sequencer *osr = new ObjectStore::Sequencer(__func__);
} else {
cerr << "Mount failed with '" << cpp_strerror(ret) << "'" << std::endl;
}
- myexit(1);
+ return 1;
}
if (op == "fuse") {
int r = fuse.main();
if (r < 0) {
cerr << "failed to mount fuse: " << cpp_strerror(r) << std::endl;
- myexit(1);
+ return 1;
}
#else
cerr << "fuse support not enabled" << std::endl;
#endif
- myexit(0);
+ return 0;
}
vector<coll_t> ls;
if (ret < 0)
ret = 1;
- myexit(ret);
+ return ret;
}
ceph_options.push_back(i->c_str());
}
- global_init(
+ auto cct = global_init(
&def_args, ceph_options, CEPH_ENTITY_TYPE_OSD,
CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
DataScan data_scan;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
JournalTool jt;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
TableTool tt;
// only parse arguments from CEPH_ARGS, if in the environment
vector<const char *> env_args;
env_to_vec(env_args);
- global_init(NULL, env_args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ auto cct = global_init(NULL, env_args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY,
+ CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
int x;
list<string> rm;
list<feature_op_t> features;
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ 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);
std::string val;
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
- CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+ 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);
const char *me = argv[0];
}
}
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
std::vector<const char*>::iterator i;
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_UTILITY, 0);
rbd::Shell shell;
return shell.execute(args);
env_to_vec(args);
argv_to_vec(argc, argv, args);
- global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
- CODE_ENVIRONMENT_DAEMON,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
+ auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
for (auto i = args.begin(); i != args.end(); ++i) {
if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
shutdown_async_signal_handler();
delete mirror;
- g_ceph_context->put();
return r < 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
argv_to_vec(argc, argv, args);
env_to_vec(args);
- global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
- CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
+ auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
+ CODE_ENVIRONMENT_DAEMON,
+ CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
g_ceph_context->_conf->set_val_or_die("pid_file", "");
std::vector<const char*>::iterator i;
projects / ceph.git / commitdiff