int loop (void) {
on_start ();
if (binlog_enabled) {
double t = get_double_time ();
logprintf ("replay log start\n");
replay_log ();
logprintf ("replay log end in %lf seconds\n", get_double_time () - t);
write_binlog ();
#ifdef USE_LUA
lua_binlog_end ();
#endif
} else {
read_auth_file ();
}
update_prompt ();
assert (DC_list[dc_working_num]);
if (!DC_working || !DC_working->auth_key_id) {
// if (auth_state == 0) {
DC_working = DC_list[dc_working_num];
assert (!DC_working->auth_key_id);
dc_authorize (DC_working);
assert (DC_working->auth_key_id);
auth_state = 100;
write_auth_file ();
}
if (verbosity) {
logprintf ("Requesting info about DC...\n");
}
do_help_get_config ();
net_loop (0, mcs);
if (verbosity) {
logprintf ("DC_info: %d new DC got\n", new_dc_num);
}
int i;
for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) {
dc_authorize (DC_list[i]);
assert (DC_list[i]->auth_key_id);
write_auth_file ();
}
if (auth_state == 100 || !(DC_working->has_auth)) {
registeringStarted();
start_registering();
}
registeringFinished();
return connect_to_server();
}
void meta_service::start(const char* data_dir, bool clean_state)
{
dassert(!_started, "meta service is already started");
_data_dir = data_dir;
std::string checkpoint_path = _data_dir + "/checkpoint";
std::string oplog_path = _data_dir + "/oplog";
if (clean_state)
{
try {
if (!dsn::utils::filesystem::remove_path(checkpoint_path))
{
dassert(false, "Fail to remove file %s.", checkpoint_path.c_str());
}
if (!dsn::utils::filesystem::remove_path(oplog_path))
{
dassert(false, "Fail to remove file %s.", oplog_path.c_str());
}
}
catch (std::exception& ex)
{
ex;
}
}
else
{
if (!dsn::utils::filesystem::create_directory(_data_dir))
{
dassert(false, "Fail to create directory %s.", _data_dir.c_str());
}
if (dsn::utils::filesystem::file_exists(checkpoint_path))
{
_state->load(checkpoint_path.c_str());
}
if (dsn::utils::filesystem::file_exists(oplog_path))
{
replay_log(oplog_path.c_str());
_state->save(checkpoint_path.c_str());
if (!dsn::utils::filesystem::remove_path(oplog_path))
{
dassert(false, "Fail to remove file %s.", oplog_path.c_str());
}
}
}
_log = dsn_file_open((_data_dir + "/oplog").c_str(), O_RDWR | O_CREAT, 0666);
_balancer = new load_balancer(_state);
_failure_detector = new meta_server_failure_detector(_state, this);
// TODO: use zookeeper for leader election
_failure_detector->set_primary(primary_address());
// make sure the delay is larger than fd.grace to ensure
// all machines are in the correct state (assuming connected initially)
tasking::enqueue(LPC_LBM_START, this, &meta_service::on_load_balance_start, 0,
_opts.fd_grace_seconds * 1000);
auto err = _failure_detector->start(
_opts.fd_check_interval_seconds,
_opts.fd_beacon_interval_seconds,
_opts.fd_lease_seconds,
_opts.fd_grace_seconds,
false
);
dassert(err == ERR_OK, "FD start failed, err = %s", err.to_string());
register_rpc_handler(
RPC_CM_QUERY_NODE_PARTITIONS,
"RPC_CM_QUERY_NODE_PARTITIONS",
&meta_service::on_query_configuration_by_node
);
register_rpc_handler(
RPC_CM_QUERY_PARTITION_CONFIG_BY_INDEX,
"RPC_CM_QUERY_PARTITION_CONFIG_BY_INDEX",
&meta_service::on_query_configuration_by_index
);
register_rpc_handler(
RPC_CM_UPDATE_PARTITION_CONFIGURATION,
"RPC_CM_UPDATE_PARTITION_CONFIGURATION",
&meta_service::on_update_configuration
);
}
int rp (int argc, char *argv[])
{
cache_invalidate();
replay_log(VolA);
return 0;
}
int main (int argc, char *argv[]) {
int i;
progname = argv[0];
while ((i = getopt (argc, argv, "fhvu:m:s:t:M:F")) != -1) {
switch (i) {
case 'F':
filter_member_fan = 1;
break;
case 'v':
verbosity += 1;
break;
case 'f':
// vkprintf(2, "setting skip_rotate\n");
skip_rotate = 1;
break;
case 'h':
usage ();
return 2;
case 'u':
username = optarg;
break;
case 'm':
if (sscanf (optarg, "%d,%d", ©_rem, ©_mod) != 2 || copy_rem < 0 || copy_rem >= copy_mod) {
usage();
return 2;
}
break;
case 's':
jump_log_pos = atoll (optarg);
break;
case 't':
keep_log_limit_pos = log_limit_pos = atoll (optarg);
break;
case 'M':
if (!strncmp(optarg, "firstint", 9)) {
split_mode = SPLIT_FIRSTINT;
} else if (!strncmp(optarg, "liked", 6)) {
split_mode = SPLIT_LIKED;
} else {
usage();
return 2;
}
break;
default:
assert (0);
return 2;
}
}
if (optind >= argc || optind + 2 < argc) {
usage();
return 2;
}
if (filter_member_fan) {
vkprintf (1, "fix member_fans, fan_members mode\n");
char *p = strrchr (argv[optind], '/');
p = (p == NULL) ? argv[optind] : (p + 1);
if (!strncmp (p, "member_fans", 11)) {
want_write = member_fans_want_write;
} else if (!strncmp (p, "fan_members", 11)) {
want_write = fan_members_want_write;
} else {
kprintf ("binlogname should starts from member_fans of fan_members when command line switch -F used.\n");
exit (1);
}
}
if (log_limit_pos >= 0) {
if (jump_log_pos > log_limit_pos) {
fprintf (stderr, "fatal: log start position %lld after stop position %lld\n", jump_log_pos, log_limit_pos);
return 2;
}
}
if (username && change_user (username) < 0) {
fprintf (stderr, "fatal: cannot change user to %s\n", username ? username : "******");
return 1;
}
if (engine_preload_filelist (argv[optind], binlogname) < 0) {
fprintf (stderr, "cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]);
exit (1);
}
Binlog = open_binlog (engine_replica, 0);
if (!Binlog) {
fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, 0LL);
exit (1);
}
binlogname = Binlog->info->filename;
if (verbosity) {
fprintf (stderr, "replaying binlog file %s (size %lld)\n", binlogname, Binlog->info->file_size);
}
clear_log();
init_log_data (0, 0, 0);
if (optind + 1 < argc) {
targ_fname = argv[optind+1];
targ_fd = open (targ_fname, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (targ_fd < 0) {
fprintf (stderr, "cannot create %s: %m\n", targ_fname);
return 1;
}
targ_orig_size = lseek (targ_fd, 0, SEEK_END);
targ_existed = (targ_orig_size > 0);
} else {
targ_fname = "stdout";
targ_fd = 1;
}
if (jump_log_pos > 0) {
log_limit_pos = 256;
immediate_exit = 1;
i = replay_log (0, 1);
if (!list_id_ints) {
fprintf (stderr, "fatal: cannot parse first LEV_START entry");
exit (1);
}
log_limit_pos = keep_log_limit_pos;
immediate_exit = 0;
clear_log ();
close_binlog (Binlog, 1);
Binlog = 0;
Binlog = open_binlog (engine_replica, jump_log_pos);
if (!Binlog) {
fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, jump_log_pos);
exit (1);
}
binlogname = Binlog->info->filename;
if (verbosity) {
fprintf (stderr, "replaying binlog file %s (size %lld) from log position %lld\n", binlogname, Binlog->info->file_size, jump_log_pos);
}
init_log_data (jump_log_pos, 0, 0);
}
i = replay_log (0, 1);
if (i < 0) {
fprintf (stderr, "fatal: error reading binlog\n");
exit (1);
}
if (log_limit_pos >= 0 && log_readto_pos != log_limit_pos) {
fprintf (stderr, "fatal: binlog read up to position %lld instead of %lld\n", log_readto_pos, log_limit_pos);
exit (1);
}
if (!targ_orig_size && !jump_log_pos) {
vkprintf (1, "Writing CRC32 to the end of target binlog.\n");
struct lev_crc32 *C = write_alloc (20);
C->type = LEV_CRC32;
C->timestamp = last_timestamp;
C->pos = wr_bytes;
C->crc32 = ~wr_crc32_complement;
wr_bytes += 20;
wr_rec++;
}
flush_out ();
if (targ_fd != 1) {
if (fdatasync (targ_fd) < 0) {
fprintf (stderr, "error syncing %s: %m", targ_fname);
exit (1);
}
close (targ_fd);
}
if (verbosity > 0) {
output_stats ();
}
return 0;
}
int main (int argc, char *argv[]) {
int i;
progname = argv[0];
while ((i = getopt (argc, argv, "hvu:m:s:t:p")) != -1) {
switch (i) {
case 'p':
fits = positive_counter_fits;
break;
case 'v':
verbosity = 1;
break;
case 'h':
usage();
return 2;
case 'u':
username = optarg;
break;
case 'm':
if (sscanf (optarg, "%d,%d", ©_rem, ©_mod) != 2 || copy_rem < 0 || copy_rem >= copy_mod) {
usage();
return 2;
}
break;
case 's':
jump_log_pos = atoll (optarg);
break;
case 't':
log_limit_pos = atoll (optarg);
break;
}
}
if (copy_mod < 0) {
usage ();
return 2;
}
if (optind >= argc || optind + 2 < argc) {
usage();
return 2;
}
if (log_limit_pos >= 0) {
if (jump_log_pos > log_limit_pos) {
fprintf (stderr, "fatal: log start position %lld after stop position %lld\n", jump_log_pos, log_limit_pos);
return 2;
}
}
if (username && change_user (username) < 0) {
fprintf (stderr, "fatal: cannot change user to %s\n", username ? username : "******");
return 1;
}
if (engine_preload_filelist (argv[optind], binlogname) < 0) {
fprintf (stderr, "cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]);
exit (1);
}
Binlog = open_binlog (engine_replica, jump_log_pos);
if (!Binlog) {
fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, 0LL);
exit (1);
}
binlogname = Binlog->info->filename;
if (verbosity) {
fprintf (stderr, "replaying binlog file %s (size %lld)\n", binlogname, Binlog->info->file_size);
}
clear_log();
init_log_data (jump_log_pos, 0, 0);
if (jump_log_pos > 0) {
init_stats_data (0);
}
if (optind + 1 < argc) {
targ_fname = argv[optind+1];
targ_fd = open (targ_fname, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (targ_fd < 0) {
fprintf (stderr, "cannot create %s: %m\n", targ_fname);
return 1;
}
targ_orig_size = lseek (targ_fd, 0, SEEK_END);
targ_existed = (targ_orig_size > 0);
} else {
targ_fname = "stdout";
targ_fd = 1;
}
i = replay_log (0, 1);
if (i < 0) {
fprintf (stderr, "fatal: error reading binlog\n");
exit (1);
}
if (log_limit_pos >= 0 && log_readto_pos != log_limit_pos) {
fprintf (stderr, "fatal: binlog read up to position %lld instead of %lld\n", log_readto_pos, log_limit_pos);
exit (1);
}
flush_out ();
if (targ_fd != 1) {
if (fdatasync (targ_fd) < 0) {
fprintf (stderr, "error syncing %s: %m", targ_fname);
exit (1);
}
close (targ_fd);
}
if (verbosity > 0) {
output_stats ();
}
return 0;
}
struct ospf_interface* add_interface(struct replay_interface *iface, u_int32_t area) {
struct ospf_interface *new_if, *tmp_if;
struct replay_list *tmp_item;
struct ip_mreq mreq;
struct sockaddr_in *sin = (struct sockaddr_in *)&iface->ifr->ifr_addr;
char ifname[256];
int duplicate=FALSE;
strcpy(ifname,iface->name);
tmp_item = ospf0->iflist;
if(tmp_item) {
tmp_if = (struct ospf_interface*)tmp_item->object;
}
while(tmp_item && tmp_if) {
if(!strcmp(ifname,tmp_if->iface->name)) {
duplicate = TRUE;
new_if = tmp_if;
tmp_item = NULL;
tmp_if = NULL;
}
else {
tmp_item = tmp_item->next;
if(!tmp_item)
tmp_if = (struct ospf_interface*)tmp_item->object;
}
}
if(!duplicate) {
new_if = (struct ospf_interface *) malloc(sizeof(*new_if));
memset(new_if,0,sizeof(*new_if));
new_if->area_id = area;
new_if->iface = iface;
new_if->pflist = NULL;
new_if->nbrlist = NULL;
new_if->lsalist = NULL;
new_if->metric = ospf0->ref_bandwdith / iface->speed;
inet_pton(AF_INET,"0.0.0.0",&new_if->bdr);
inet_pton(AF_INET,"0.0.0.0",&new_if->dr);
new_if->priority = ospf0->priority;
new_if->auth_type = OSPF_AUTHTYPE_NONE;
memset(&new_if->auth_data, 0, sizeof(new_if->auth_data));
ospf0->iflist = add_to_list(ospf0->iflist,(void *)new_if);
new_if->ospf_socket = socket(AF_INET,SOCK_RAW,89);
if(new_if->ospf_socket<0)
replay_error("add_interface: Error opening socket");
else
replay_log("add_interface: socket opened");
if (setsockopt(new_if->ospf_socket, SOL_SOCKET, SO_BINDTODEVICE, iface->ifr, sizeof(*iface->ifr)) < 0)
replay_error("add_interface: ERROR on interface binding");
else
replay_log("add_interface: socket bound to interface");
mreq.imr_interface.s_addr = sin->sin_addr.s_addr;
inet_pton(AF_INET,OSPF_MULTICAST_ALLROUTERS,&mreq.imr_multiaddr);
if(setsockopt(new_if->ospf_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq))<0)
replay_error("add_interface: ERROR on multicast join");
else
replay_log("add_interface: multicast group added");
FD_SET(new_if->ospf_socket, &ospf0->ospf_sockets_in);
FD_SET(new_if->ospf_socket, &ospf0->ospf_sockets_out);
FD_SET(new_if->ospf_socket, &ospf0->ospf_sockets_err);
if(new_if->ospf_socket > ospf0->max_socket) {
ospf0->max_socket = new_if->ospf_socket;
}
ospf0->ifcount++;
add_event((void *)new_if,OSPF_EVENT_HELLO_BROADCAST);
add_event((void *)new_if,OSPF_EVENT_NO_DR);
if(new_if->iface->virtual && new_if->iface->replay) {
load_lsalist(new_if);
}
}
int loop (void) {
on_start ();
if (binlog_enabled) {
replay_log ();
write_binlog ();
} else {
read_auth_file ();
}
update_prompt ();
assert (DC_list[dc_working_num]);
if (!DC_working || !DC_working->auth_key_id) {
// if (auth_state == 0) {
DC_working = DC_list[dc_working_num];
assert (!DC_working->auth_key_id);
dc_authorize (DC_working);
assert (DC_working->auth_key_id);
auth_state = 100;
write_auth_file ();
}
if (verbosity) {
logprintf ("Requesting info about DC...\n");
}
do_help_get_config ();
net_loop (0, mcs);
if (verbosity) {
logprintf ("DC_info: %d new DC got\n", new_dc_num);
}
int i;
for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) {
dc_authorize (DC_list[i]);
assert (DC_list[i]->auth_key_id);
write_auth_file ();
}
if (auth_state == 100 || !(DC_working->has_auth)) {
if (!default_username) {
size_t size = 0;
char *user = 0;
if (!user) {
printf ("Telephone number (with '+' sign): ");
if (net_getline (&user, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
set_default_username (user);
}
}
int res = do_auth_check_phone (default_username);
assert (res >= 0);
logprintf ("%s\n", res > 0 ? "phone registered" : "phone not registered");
if (res > 0) {
do_send_code (default_username);
char *code = 0;
size_t size = 0;
printf ("Code from sms: ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (do_send_code_result (code) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
free (code);
}
auth_state = 300;
} else {
printf ("User is not registered. Do you want to register? [Y/n] ");
char *code;
size_t size;
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (!*code || *code == 'y' || *code == 'Y') {
printf ("Ok, starting registartion.\n");
} else {
printf ("Then try again\n");
exit (EXIT_SUCCESS);
}
char *first_name;
printf ("Name: ");
if (net_getline (&first_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
char *last_name;
printf ("Name: ");
if (net_getline (&last_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
int dc_num = do_get_nearest_dc ();
assert (dc_num >= 0 && dc_num <= MAX_DC_NUM && DC_list[dc_num]);
dc_working_num = dc_num;
DC_working = DC_list[dc_working_num];
do_send_code (default_username);
printf ("Code from sms: ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (do_send_code_result_auth (code, first_name, last_name) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
free (code);
}
auth_state = 300;
}
}
for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->has_auth) {
do_export_auth (i);
do_import_auth (i);
DC_list[i]->has_auth = 1;
if (binlog_enabled) {
int *ev = alloc_log_event (8);
ev[0] = LOG_DC_SIGNED;
ev[1] = i;
add_log_event (ev, 8);
}
write_auth_file ();
}
write_auth_file ();
fflush (stdin);
fflush (stdout);
fflush (stderr);
read_state_file ();
read_secret_chat_file ();
set_interface_callbacks ();
do_get_difference ();
net_loop (0, dgot);
do_get_dialog_list ();
return main_loop ();
}
void meta_service::start(const char* data_dir, bool clean_state)
{
_data_dir = data_dir;
if (clean_state)
{
try {
boost::filesystem::remove(_data_dir + "/checkpoint");
boost::filesystem::remove(_data_dir + "/oplog");
}
catch (std::exception& ex)
{
ex;
}
}
else
{
if (!boost::filesystem::exists(_data_dir))
{
boost::filesystem::create_directory(_data_dir);
}
if (boost::filesystem::exists(_data_dir + "/checkpoint"))
{
_state->load((_data_dir + "/checkpoint").c_str());
}
if (boost::filesystem::exists(_data_dir + "/oplog"))
{
replay_log((_data_dir + "/oplog").c_str());
_state->save((_data_dir + "/checkpoint").c_str());
boost::filesystem::remove(_data_dir + "/oplog");
}
}
_log = file::open((_data_dir + "/oplog").c_str(), O_RDWR | O_CREAT, 0666);
_balancer = new load_balancer(_state);
_failure_detector = new meta_server_failure_detector(_state);
end_point primary;
if (_state->get_meta_server_primary(primary) && primary == primary_address())
{
_failure_detector->set_primary(true);
}
else
_failure_detector->set_primary(false);
register_rpc_handler(RPC_CM_CALL, "RPC_CM_CALL", &meta_service::on_request);
_balancer_timer = tasking::enqueue(LPC_LBM_RUN, this, &meta_service::on_load_balance_timer, 0,
_opts.fd_grace_seconds * 1000 + 1, // delay
10000
);
_failure_detector->start(
_opts.fd_check_interval_seconds,
_opts.fd_beacon_interval_seconds,
_opts.fd_lease_seconds,
_opts.fd_grace_seconds,
false
);
}
int loop (void) {
on_start ();
if (binlog_enabled) {
double t = get_double_time ();
logprintf ("replay log start\n");
replay_log ();
logprintf ("replay log end in %lf seconds\n", get_double_time () - t);
write_binlog ();
#ifdef USE_LUA
lua_binlog_end ();
#endif
} else {
read_auth_file ();
}
update_prompt ();
assert (DC_list[dc_working_num]);
if (!DC_working || !DC_working->auth_key_id) {
// if (auth_state == 0) {
DC_working = DC_list[dc_working_num];
assert (!DC_working->auth_key_id);
dc_authorize (DC_working);
assert (DC_working->auth_key_id);
auth_state = 100;
write_auth_file ();
}
if (verbosity) {
logprintf ("Requesting info about DC...\n");
}
do_help_get_config ();
net_loop (0, mcs);
if (verbosity) {
logprintf ("DC_info: %d new DC got\n", new_dc_num);
}
int i;
for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) {
dc_authorize (DC_list[i]);
assert (DC_list[i]->auth_key_id);
write_auth_file ();
}
if (auth_state == 100 || !(DC_working->has_auth)) {
if (!default_username) {
size_t size = 0;
char *user = 0;
if (!user) {
printf ("Telephone number (with '+' sign): ");
if (net_getline (&user, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
set_default_username (user);
}
}
int res = do_auth_check_phone (default_username);
assert (res >= 0);
logprintf ("%s\n", res > 0 ? "phone registered" : "phone not registered");
if (res > 0 && !register_mode) {
do_send_code (default_username);
char *code = 0;
size_t size = 0;
printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (!strcmp (code, "call")) {
printf ("You typed \"call\", switching to phone system.\n");
do_phone_call (default_username);
printf ("Calling you! Code: ");
continue;
}
if (do_send_code_result (code) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
tfree_str (code);
}
auth_state = 300;
} else {
printf ("User is not registered. Do you want to register? [Y/n] ");
char *code;
size_t size;
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (!*code || *code == 'y' || *code == 'Y') {
printf ("Ok, starting registartion.\n");
} else {
printf ("Then try again\n");
exit (EXIT_SUCCESS);
}
char *first_name;
printf ("First name: ");
if (net_getline (&first_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
char *last_name;
printf ("Last name: ");
if (net_getline (&last_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
int dc_num = do_get_nearest_dc ();
assert (dc_num >= 0 && dc_num <= MAX_DC_NUM && DC_list[dc_num]);
dc_working_num = dc_num;
DC_working = DC_list[dc_working_num];
do_send_code (default_username);
printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
if (!strcmp (code, "call")) {
printf ("You typed \"call\", switching to phone system.\n");
do_phone_call (default_username);
printf ("Calling you! Code: ");
continue;
}
if (do_send_code_result_auth (code, first_name, last_name) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
tfree_str (code);
}
auth_state = 300;
}
}
for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->has_auth) {
do_export_auth (i);
do_import_auth (i);
bl_do_dc_signed (i);
write_auth_file ();
}
write_auth_file ();
fflush (stdout);
fflush (stderr);
read_state_file ();
read_secret_chat_file ();
set_interface_callbacks ();
do_get_difference ();
net_loop (0, dgot);
#ifdef USE_LUA
lua_diff_end ();
#endif
send_all_unsent ();
do_get_dialog_list ();
if (wait_dialog_list) {
dialog_list_got = 0;
net_loop (0, dlgot);
}
return main_loop ();
}
int main (int argc, char *argv[]) {
int i;
char new_binlog = 0;
set_debug_handlers ();
progname = argv[0];
while ((i = getopt (argc, argv, "a:b:c:l:p:dhu:vEM:")) != -1) {
switch (i) {
case 'E':
new_binlog = 1;
break;
case 'M':
if (sscanf (optarg, "%d", &i) != 1 || i < 1) {
kprintf ("invalid -M arg: %s", optarg);
usage ();
}
max_lru_size = i;
break;
case 'a':
binlogname = optarg;
break;
case 'b':
backlog = atoi (optarg);
if (backlog <= 0) backlog = BACKLOG;
break;
case 'c':
maxconn = atoi (optarg);
if (maxconn <= 0 || maxconn > MAX_CONNECTIONS) {
maxconn = MAX_CONNECTIONS;
}
break;
case 'd':
daemonize ^= 1;
break;
case 'h':
usage ();
break;
case 'l':
logname = optarg;
break;
case 'p':
port = atoi(optarg);
break;
case 'u':
username = optarg;
break;
case 'v':
verbosity++;
break;
}
}
if (argc != optind + 1) {
usage ();
}
if (raise_file_rlimit (maxconn + 16) < 0) {
kprintf ("fatal: cannot raise open file limit to %d\n", maxconn+16);
exit (1);
}
aes_load_pwd_file (0);
if (change_user (username) < 0) {
kprintf ("fatal: cannot change user to %s\n", username ? username : "******");
exit (1);
}
if (new_binlog) {
copyexec_results_make_empty_binlog (argv[optind]);
exit (0);
}
init_dyn_data ();
if (engine_preload_filelist (argv[optind], binlogname) < 0) {
kprintf ("cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]);
exit (1);
}
vkprintf (3, "engine_preload_filelist done\n");
//Binlog reading
Binlog = open_binlog (engine_replica, jump_log_pos);
if (!Binlog) {
kprintf ("fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, jump_log_pos);
exit (1);
}
binlogname = Binlog->info->filename;
vkprintf (1, "replaying binlog file %s (size %lld) from position %lld\n", binlogname, Binlog->info->file_size, jump_log_pos);
binlog_load_time = -mytime();
clear_log ();
init_log_data (jump_log_pos, jump_log_ts, jump_log_crc32);
vkprintf (1, "replay log events started\n");
i = replay_log (0, 1);
vkprintf (1, "replay log events finished\n");
if (i < 0) {
kprintf ("fatal: error reading binlog\n");
exit (1);
}
binlog_load_time += mytime();
binlog_loaded_size = log_readto_pos - jump_log_pos;
if (!binlog_disabled) {
clear_read_log();
}
clear_write_log ();
start_time = time (0);
start_server ();
return 0;
}
void meta_service::start(const char* data_dir, bool clean_state)
{
dassert(!_started, "meta service is already started");
_data_dir = data_dir;
std::string checkpoint_path = _data_dir + "/checkpoint";
std::string oplog_path = _data_dir + "/oplog";
if (clean_state)
{
try {
if (!dsn::utils::filesystem::remove_path(checkpoint_path))
{
dassert(false, "Fail to remove file %s.", checkpoint_path.c_str());
}
if (!dsn::utils::filesystem::remove_path(oplog_path))
{
dassert(false, "Fail to remove file %s.", oplog_path.c_str());
}
}
catch (std::exception& ex)
{
ex;
}
}
else
{
if (!dsn::utils::filesystem::create_directory(_data_dir))
{
dassert(false, "Fail to create directory %s.", _data_dir.c_str());
}
if (dsn::utils::filesystem::file_exists(checkpoint_path))
{
_state->load(checkpoint_path.c_str());
}
if (dsn::utils::filesystem::file_exists(oplog_path))
{
replay_log(oplog_path.c_str());
_state->save(checkpoint_path.c_str());
if (!dsn::utils::filesystem::remove_path(oplog_path))
{
dassert(false, "Fail to remove file %s.", oplog_path.c_str());
}
}
}
_log = dsn_file_open((_data_dir + "/oplog").c_str(), O_RDWR | O_CREAT, 0666);
_balancer = new load_balancer(_state);
_failure_detector = new meta_server_failure_detector(_state, this);
::dsn::rpc_address primary;
if (_state->get_meta_server_primary(primary) && primary == primary_address())
{
_failure_detector->set_primary(true);
}
else
_failure_detector->set_primary(false);
register_rpc_handler(RPC_CM_CALL, "RPC_CM_CALL", &meta_service::on_request);
// make sure the delay is larger than fd.grace to ensure
// all machines are in the correct state (assuming connected initially)
tasking::enqueue(LPC_LBM_START, this, &meta_service::on_load_balance_start, 0,
_opts.fd_grace_seconds * 1000);
auto err = _failure_detector->start(
_opts.fd_check_interval_seconds,
_opts.fd_beacon_interval_seconds,
_opts.fd_lease_seconds,
_opts.fd_grace_seconds,
false
);
dassert(err == ERR_OK, "FD start failed, err = %s", err.to_string());
}