int main(int argc, char** argv)
{
if (argc != 3)
{
std::cerr << "USGAE: " << argv[0] << " <config-file> <case-input>" << std::endl;
std::cerr << " e.g.: " << argv[0] << " case-000.ini case-000.act" << std::endl;
return -1;
}
dsn::replication::test::g_case_input = argv[2];
dsn_app_registration();
dsn_core_init();
// specify what services and tools will run in config file, then run
dsn_run(argc - 1, argv, false);
while (!dsn::replication::test::g_done)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
ddebug("=== exiting ...");
dsn::replication::test::test_checker::instance().exit();
if (dsn::replication::test::g_fail)
{
#ifndef ENABLE_GCOV
dsn_exit(-1);
#endif
return -1;
}
#ifndef ENABLE_GCOV
dsn_exit(0);
#endif
return 0;
}
//
// run the system with arguments
// config [-cargs k1=v1;k2=v2] [-app_list app_name1@index1;app_name2@index]
// e.g., config.ini -app_list replica@1 to start the first replica as a new process
// config.ini -app_list replica to start ALL replicas (count specified in config) as a new process
// config.ini -app_list replica -cargs replica-port=34556 to start ALL replicas with given port variable specified in config.ini
// config.ini to start ALL apps as a new process
//
DSN_API void dsn_run(int argc, char** argv, bool sleep_after_init)
{
if (argc < 2)
{
printf("invalid options for dsn_run\n"
"// run the system with arguments\n"
"// config [-cargs k1=v1;k2=v2] [-app_list app_name1@index1;app_name2@index]\n"
"// e.g., config.ini -app_list replica@1 to start the first replica as a new process\n"
"// config.ini -app_list replica to start ALL replicas (count specified in config) as a new process\n"
"// config.ini -app_list replica -cargs replica-port=34556 to start with %%replica-port%% var in config.ini\n"
"// config.ini to start ALL apps as a new process\n"
);
exit(1);
return;
}
char* config = argv[1];
std::string config_args = "";
std::string app_list = "";
for (int i = 2; i < argc;)
{
if (0 == strcmp(argv[i], "-cargs"))
{
if (++i < argc)
{
config_args = std::string(argv[i++]);
}
}
else if (0 == strcmp(argv[i], "-app_list"))
{
if (++i < argc)
{
app_list = std::string(argv[i++]);
}
}
else
{
printf("unknown arguments %s\n", argv[i]);
exit(1);
return;
}
}
if (!run(config, config_args.size() > 0 ? config_args.c_str() : nullptr, sleep_after_init, app_list))
{
printf("run the system failed\n");
dsn_exit(-1);
return;
}
}
::dsn::error_code meta_service_app::start(int argc, char** argv)
{
if (argc == 4)
{
//for dump and restore
server_state *state = new server_state();
error_code ec = state->initialize();
if (ec != ERR_OK)
{
derror("initialize failed, err=%s", ec.to_string());
dsn_exit(0);
}
if (strcmp(argv[1], "dump") == 0)
{
ec = state->dump_from_remote_storage(argv[2], argv[3], true);
}
else if (strcmp(argv[1], "restore") == 0)
{
bool write_back_to_remote = false;
if (strcmp(argv[3], "write_back") == 0)
write_back_to_remote = true;
ec = state->restore_from_local_storage(argv[2], write_back_to_remote);
}
else
{
dassert(false, "unsupported command arguments");
}
if (ec != ERR_OK)
{
derror("%s failed, err=%s", argv[1], ec.to_string());
}
dsn_exit(0);
}
else
return _service->start();
}
void meta_server_failure_detector::acquire_leader_lock()
{
//
// try to get the leader lock until it is done
//
dsn::dist::distributed_lock_service::lock_options opt = {true, true};
std::string local_owner_id;
while (true)
{
error_code err;
auto tasks =
_lock_svc->lock(
_primary_lock_id,
primary_address().to_std_string(),
// lock granted
LPC_META_SERVER_LEADER_LOCK_CALLBACK,
[this, &err, &local_owner_id](error_code ec, const std::string& owner, uint64_t version)
{
err = ec;
local_owner_id = owner;
},
// lease expire
LPC_META_SERVER_LEADER_LOCK_CALLBACK,
[this](error_code ec, const std::string& owner, uint64_t version)
{
// let's take the easy way right now
dsn_exit(0);
},
opt
);
_lock_grant_task = tasks.first;
_lock_expire_task = tasks.second;
_lock_grant_task->wait();
if (err == ERR_OK)
{
rpc_address addr;
if (addr.from_string_ipv4(local_owner_id.c_str()))
{
dassert(primary_address() == addr, "");
set_primary(addr);
break;
}
}
}
}
GTEST_API_ int main(int argc, char **argv)
{
dsn::service_app::register_factory<replication_service_test_app>("replica");
if (argc < 2)
dassert(dsn_run_config("config-test.ini", false), "");
else
dassert(dsn_run_config(argv[1], false), "");
while (gtest_flags == 0) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
#ifndef ENABLE_GCOV
dsn_exit(gtest_ret);
#endif
return gtest_ret;
}
GTEST_API_ int main(int argc, char **argv)
{
// register all possible services
dsn::register_app<test_client>("test");
lock_test_init();
fd_test_init();
// specify what services and tools will run in config file, then run
dsn_run_config("config-test.ini", false);
while (g_test_count == 0)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
#ifndef ENABLE_GCOV
dsn_exit(g_test_ret);
#endif
return g_test_ret;
}
