static int
child_main() {
/* reload our config, to make sure we have the most current */
if(mtev_conf_load(NULL) == -1) {
mtevL(mtev_error, "Cannot load config: '%s'\n", config_file);
exit(2);
}
eventer_init();
mtev_console_init(APPNAME);
mtev_capabilities_listener_init();
mtev_events_rest_init();
mtev_listener_init(APPNAME);
mtev_dso_init();
mtev_dso_post_init();
mtev_websocket_client_callbacks callbacks = {
websocket_ready_handler,
websocket_msg_handler,
websocket_cleanup_handler
};
(void)mtev_websocket_client_new("127.0.0.1", 8888, "/", "echo-protocol", &callbacks);
/* Lastly, spin up the event loop */
eventer_loop();
return 0;
}
static int
child_main() {
/* reload our config, to make sure we have the most current */
if(mtev_conf_load(NULL) == -1) {
mtevL(mtev_error, "Cannot load config: '%s'\n", config_file);
exit(2);
}
eventer_init();
mtev_console_init(APPNAME);
mtev_http_rest_init();
mtev_capabilities_listener_init();
mtev_events_rest_init();
mtev_listener_init(APPNAME);
mtev_dso_init();
mtev_dso_post_init();
mtev_http_rest_register("GET", "/", "^(.*)$", my_rest_handler);
/* for 'echo-protocol' see websocket_client.js */
mtev_http_rest_websocket_register("/", "^(.*)$", "echo-protocol", my_websocket_msg_handler);
/* Lastly, spin up the event loop */
eventer_loop();
return 0;
}
static int
child_main() {
int log_flags;
mtev_conf_section_t section;
char *err = NULL;
cli_stdout = mtev_log_stream_new_on_fd("stdout", 1, NULL);
log_flags = mtev_log_stream_get_flags(mtev_stderr);
log_flags &= ~(MTEV_LOG_STREAM_FACILITY|MTEV_LOG_STREAM_TIMESTAMPS);
mtev_log_stream_set_flags(mtev_stderr, log_flags);
/* reload our config, to make sure we have the most current */
if(mtev_conf_load(NULL) == -1) {
mtevL(mtev_error, "Cannot load config: '%s'\n", config_file);
if(needs_unlink) unlink(config_file);
exit(2);
}
mtev_conf_security_init(APPNAME, droptouser, droptogroup, NULL);
if(mtev_conf_write_file(&err) != 0) {
if(err) {
mtevL(mtev_stderr, "Error: '%s'\n", err);
free(err);
}
mtevL(mtev_stderr, "Permissions issue, are you running as the right user?\n");
exit(2);
}
if(needs_unlink) unlink(config_file);
/* update the lua module */
section = mtev_conf_get_section(NULL, "/cli/modules/generic[@name=\"lua_general\"]/config");
if(!section || !mtev_conf_set_string(section, "lua_module", lua_file)) {
mtevL(mtev_stderr, "Cannot set target lua module, invalid config.\n");
exit(2);
}
eventer_init();
mtev_dso_init();
mtev_dso_post_init();
if(mtev_dso_load_failures() > 0) {
mtevL(mtev_stderr, "Failed to initialize.\n");
exit(2);
}
if(interactive) {
mtev_console_init(APPNAME);
mtev_console_conf_init(APPNAME);
eventer_set_fd_nonblocking(STDIN_FILENO);
if(mtev_console_std_init(STDIN_FILENO, STDOUT_FILENO)) {
mtevL(mtev_stderr, "Failed to initialize IO\n");
exit(2);
}
}
/* Lastly, spin up the event loop */
eventer_loop();
return 0;
}
static int child_main() {
char conf_str[1024];
char stratcon_version[80];
mtev_watchdog_child_heartbeat();
/* Next (re)load the configs */
if(mtev_conf_load(config_file) == -1) {
fprintf(stderr, "Cannot load config: '%s'\n", config_file);
exit(2);
}
mtev_log_reopen_all();
mtevL(noit_notice, "process starting: %d\n", (int)getpid());
mtev_log_go_asynch();
/* Lastly, run through all other system inits */
if(!mtev_conf_get_stringbuf(NULL, "/" APPNAME "/eventer/@implementation",
conf_str, sizeof(conf_str))) {
mtevL(noit_stderr, "Cannot find '%s' in configuration\n",
"/" APPNAME "/eventer/@implementation");
exit(2);
}
if(eventer_choose(conf_str) == -1) {
mtevL(noit_stderr, "Cannot choose eventer %s\n", conf_str);
exit(2);
}
if(configure_eventer() != 0) {
mtevL(noit_stderr, "Cannot configure eventer\n");
exit(2);
}
if(eventer_init() == -1) {
mtevL(noit_stderr, "Cannot init eventer %s\n", conf_str);
exit(2);
}
/* rotation init requires, eventer_init() */
mtev_conf_log_init_rotate(APPNAME, mtev_false);
mtev_watchdog_child_eventer_heartbeat();
mtev_console_init(APPNAME);
mtev_console_conf_init();
mtev_http_rest_init();
mtev_reverse_socket_init(reverse_prefix, reverse_prefix_cns);
mtev_reverse_socket_acl(mtev_reverse_socket_denier);
mtev_events_rest_init();
stratcon_realtime_http_init(APPNAME);
mtev_capabilities_listener_init();
noit_build_version(stratcon_version, sizeof(stratcon_version));
mtev_capabilities_add_feature("stratcon", stratcon_version);
mtev_listener_init(APPNAME);
mtev_dso_init();
mtev_dso_post_init();
if(strict_module_load && mtev_dso_load_failures() > 0) {
mtevL(noit_stderr, "Failed to load some modules and -M given.\n");
exit(2);
}
if(stratcon_datastore_get_enabled())
stratcon_datastore_init();
/* Drop privileges */
mtev_conf_security_init(APPNAME, droptouser, droptogroup, chrootpath);
stratcon_jlog_streamer_init(APPNAME);
if(stratcon_iep_get_enabled())
stratcon_iep_init();
if(stratcon_datastore_get_enabled()) {
/* Write our log out, and setup a watchdog to write it out on change. */
stratcon_datastore_saveconfig(NULL);
mtev_conf_coalesce_changes(10); /* 10 seconds of no changes before we write */
}
else
mtev_conf_coalesce_changes(INT_MAX);
mtev_conf_watch_and_journal_watchdog(stratcon_datastore_saveconfig, NULL);
eventer_loop();
return 0;
}
int
mtev_main(const char *appname,
const char *config_filename, int debug, int foreground,
mtev_lock_op_t lock, const char *_glider,
const char *drop_to_user, const char *drop_to_group,
int (*passed_child_main)(void)) {
mtev_conf_section_t watchdog_conf;
int fd, lockfd, watchdog_timeout = 0, rv;
int wait_for_lock;
char conf_str[1024];
char lockfile[PATH_MAX];
char *trace_dir = NULL;
char appscratch[1024];
char *glider = (char *)_glider;
char *watchdog_timeout_str;
int retry_val;
int span_val;
int ret;
int cnt;
mtev_conf_section_t root;
wait_for_lock = (lock == MTEV_LOCK_OP_WAIT) ? 1 : 0;
mtev_init_globals();
char *require_invariant_tsc = getenv("MTEV_RDTSC_REQUIRE_INVARIANT");
if (require_invariant_tsc && strcmp(require_invariant_tsc, "0") == 0) {
mtev_time_toggle_require_invariant_tsc(mtev_false);
}
char *disable_rdtsc = getenv("MTEV_RDTSC_DISABLE");
if (disable_rdtsc && strcmp(disable_rdtsc, "1") == 0) {
mtev_time_toggle_tsc(mtev_false);
}
char *disable_binding = getenv("MTEV_THREAD_BINDING_DISABLE");
if (disable_binding && strcmp(disable_binding, "1") == 0) {
mtev_thread_disable_binding();
}
/* First initialize logging, so we can log errors */
mtev_log_init(debug);
mtev_log_stream_add_stream(mtev_debug, mtev_stderr);
mtev_log_stream_add_stream(mtev_error, mtev_stderr);
mtev_log_stream_add_stream(mtev_notice, mtev_error);
/* Next load the configs */
mtev_conf_use_namespace(appname);
mtev_conf_init(appname);
if(mtev_conf_load(config_filename) == -1) {
fprintf(stderr, "Cannot load config: '%s'\n", config_filename);
exit(-1);
}
char* root_section_path = alloca(strlen(appname)+2);
sprintf(root_section_path, "/%s", appname);
root = mtev_conf_get_sections(NULL, root_section_path, &cnt);
free(root);
if(cnt==0) {
fprintf(stderr, "The config must have <%s> as its root node\n", appname);
exit(-1);
}
/* Reinitialize the logging system now that we have a config */
mtev_conf_log_init(appname, drop_to_user, drop_to_group);
if(debug) {
mtev_log_stream_set_flags(mtev_debug, mtev_log_stream_get_flags(mtev_debug) | MTEV_LOG_STREAM_ENABLED);
}
cli_log_switches();
snprintf(appscratch, sizeof(appscratch), "/%s/watchdog|/%s/include/watchdog", appname, appname);
watchdog_conf = mtev_conf_get_section(NULL, appscratch);
if(!glider) (void) mtev_conf_get_string(watchdog_conf, "@glider", &glider);
if(mtev_watchdog_glider(glider)) {
mtevL(mtev_stderr, "Invalid glider, exiting.\n");
exit(-1);
}
(void)mtev_conf_get_string(watchdog_conf, "@tracedir", &trace_dir);
if(trace_dir) {
if(mtev_watchdog_glider_trace_dir(trace_dir)) {
mtevL(mtev_stderr, "Invalid glider tracedir, exiting.\n");
exit(-1);
}
}
ret = mtev_conf_get_int(watchdog_conf, "@retries", &retry_val);
if((ret == 0) || (retry_val == 0)) {
retry_val = 5;
}
ret = mtev_conf_get_int(watchdog_conf, "@span", &span_val);
if((ret == 0) || (span_val == 0)) {
span_val = 60;
}
mtev_watchdog_ratelimit(retry_val, span_val);
/* Lastly, run through all other system inits */
snprintf(appscratch, sizeof(appscratch), "/%s/eventer/@implementation", appname);
if(!mtev_conf_get_stringbuf(NULL, appscratch, conf_str, sizeof(conf_str))) {
mtevL(mtev_stderr, "Cannot find '%s' in configuration\n", appscratch);
exit(-1);
}
if(eventer_choose(conf_str) == -1) {
mtevL(mtev_stderr, "Cannot choose eventer %s\n", conf_str);
exit(-1);
}
if(configure_eventer(appname) != 0) {
mtevL(mtev_stderr, "Cannot configure eventer\n");
exit(-1);
}
mtev_watchdog_prefork_init();
if(foreground != 1 && chdir("/") != 0) {
mtevL(mtev_stderr, "Failed chdir(\"/\"): %s\n", strerror(errno));
exit(-1);
}
/* Acquire the lock so that we can throw an error if it doesn't work.
* If we've started -D, we'll have the lock.
* If not we will daemon and must reacquire the lock.
*/
lockfd = -1;
lockfile[0] = '\0';
snprintf(appscratch, sizeof(appscratch), "/%s/@lockfile", appname);
if(lock != MTEV_LOCK_OP_NONE &&
mtev_conf_get_stringbuf(NULL, appscratch,
lockfile, sizeof(lockfile))) {
do {
if((lockfd = mtev_lockfile_acquire(lockfile)) < 0) {
if(!wait_for_lock) {
mtevL(mtev_stderr, "Failed to acquire lock: %s\n", lockfile);
exit(-1);
}
if(wait_for_lock == 1) {
mtevL(mtev_stderr, "%d failed to acquire lock(%s), waiting...\n",
(int)getpid(), lockfile);
wait_for_lock++;
}
usleep(1000);
}
else {
if(wait_for_lock > 1) mtevL(mtev_stderr, "Lock acquired proceeding.\n");
wait_for_lock = 0;
}
} while(wait_for_lock);
}
if(foreground == 1) {
mtev_time_start_tsc();
mtevL(mtev_notice, "%s booting [unmanaged]\n", appname);
int rv = passed_child_main();
mtev_lockfile_release(lockfd);
return rv;
}
watchdog_timeout_str = getenv("WATCHDOG_TIMEOUT");
if(watchdog_timeout_str) {
watchdog_timeout = atoi(watchdog_timeout_str);
mtevL(mtev_error, "Setting watchdog timeout to %d\n",
watchdog_timeout);
}
/* This isn't inherited across forks... */
if(lockfd >= 0) mtev_lockfile_release(lockfd);
lockfd = -1;
if(foreground == 0) {
fd = open("/dev/null", O_RDONLY);
if(fd < 0 || dup2(fd, STDIN_FILENO) < 0) {
fprintf(stderr, "Failed to setup stdin: %s\n", strerror(errno));
exit(-1);
}
close(fd);
fd = open("/dev/null", O_WRONLY);
if(fd < 0 || dup2(fd, STDOUT_FILENO) < 0 || dup2(fd, STDERR_FILENO) < 0) {
fprintf(stderr, "Failed to setup std{out,err}: %s\n", strerror(errno));
exit(-1);
}
close(fd);
if(fork()) exit(0);
setsid();
if(fork()) exit(0);
}
/* Reacquire the lock */
if(*lockfile) {
if (lock) {
if((lockfd = mtev_lockfile_acquire(lockfile)) < 0) {
mtevL(mtev_stderr, "Failed to acquire lock: %s\n", lockfile);
exit(-1);
}
}
}
signal(SIGHUP, SIG_IGN);
mtevL(mtev_notice, "%s booting\n", appname);
rv = mtev_watchdog_start_child(appname, passed_child_main, watchdog_timeout);
mtev_lockfile_release(lockfd);
return rv;
}
