void stratcon_datastore_core_init() { static int initialized = 0; if(initialized) return; initialized = 1; ds_err = mtev_log_stream_find("error/datastore"); ds_deb = mtev_log_stream_find("debug/datastore"); ds_pool_deb = mtev_log_stream_find("debug/datastore_pool"); ingest_err = mtev_log_stream_find("error/ingest"); if(!ds_err) ds_err = noit_error; if(!ingest_err) ingest_err = noit_error; if(!mtev_conf_get_string(NULL, "//database/journal/path", &basejpath)) { mtevL(noit_error, "//database/journal/path is unspecified\n"); exit(-1); } }
static iep_thread_driver_t *noit_rabbimq_allocate(mtev_conf_section_t conf) { char *hostname = NULL, *cp, *brk; struct amqp_driver *dr = NULL; int i; pthread_mutex_lock(&driver_lock); for(i=0; i<MAX_HOSTS; i++) { if(stats.thread_states[i].owner == (pthread_t)(intptr_t)NULL) { stats.thread_states[i].owner = pthread_self(); dr = &stats.thread_states[i]; break; } } pthread_mutex_unlock(&driver_lock); if(!dr) return NULL; dr->nconnects = rand(); #define GETCONFSTR(w) mtev_conf_get_stringbuf(conf, #w, dr->w, sizeof(dr->w)) GETCONFSTR(exchange); if(!GETCONFSTR(routingkey)) dr->routingkey[0] = '\0'; GETCONFSTR(username); GETCONFSTR(password); if(!GETCONFSTR(vhost)) { dr->vhost[0] = '/'; dr->vhost[1] = '\0'; } if(!mtev_conf_get_int(conf, "heartbeat", &dr->heartbeat)) dr->heartbeat = 5000; dr->heartbeat = (dr->heartbeat + 999) / 1000; (void)mtev_conf_get_string(conf, "hostname", &hostname); if(!hostname) hostname = strdup("127.0.0.1"); for(cp = hostname; cp; cp = strchr(cp+1, ',')) dr->nhosts++; if(dr->nhosts > MAX_HOSTS) dr->nhosts = MAX_HOSTS; for(i = 0, cp = strtok_r(hostname, ",", &brk); cp; cp = strtok_r(NULL, ",", &brk), i++) strlcpy(dr->hostname[i], cp, sizeof(dr->hostname[i])); free(hostname); if(!mtev_conf_get_int(conf, "port", &dr->port)) dr->port = 5672; mtev_atomic_inc64(&stats.concurrency); return (iep_thread_driver_t *)dr; }
int mtev_load_image(const char *file, const char *name, mtev_hash_table *registry, int (*validate)(mtev_image_t *), size_t obj_size) { char module_file[PATH_MAX]; const char *dlsymname; void *dlhandle = NULL; void *dlsymbol; mtev_image_t *obj; if(file[0] == '/') { strlcpy(module_file, file, sizeof(module_file)); dlhandle = dlopen(module_file, RTLD_LAZY | RTLD_GLOBAL); } else { char *basepath, *base, *brk; if(!mtev_conf_get_string(MTEV_CONF_ROOT, "//modules/@directory", &basepath)) basepath = strdup(MTEV_MODULES_DIR); for (base = strtok_r(basepath, ";:", &brk); base; base = strtok_r(NULL, ";:", &brk)) { snprintf(module_file, sizeof(module_file), "%s/%s.%s", base, file, MODULEEXT); dlhandle = dlopen(module_file, RTLD_LAZY | RTLD_GLOBAL); if(dlhandle) { mtevL(mtev_debug, "Successfully opened image '%s'\n", module_file); break; } else { mtevL(mtev_debug, "Tried to open image '%s' but failed: %s\n", module_file, dlerror()); } } free(basepath); if(!dlhandle) { snprintf(module_file, sizeof(module_file), "%s/%s.%s", MTEV_MODULES_DIR, file, MODULEEXT); dlhandle = dlopen(module_file, RTLD_LAZY | RTLD_GLOBAL); } } if(!dlhandle) { mtevL(mtev_stderr, "Cannot open image '%s': %s\n", module_file, dlerror()); return -1; } dlsymname = strrchr(name, ':'); if(!dlsymname) dlsymname = name; else dlsymname++; dlsymbol = dlsym(dlhandle, dlsymname); if(!dlsymbol) { mtevL(mtev_stderr, "Cannot find '%s' in image '%s': %s\n", dlsymname, module_file, dlerror()); dlclose(dlhandle); return -1; } if(validate(dlsymbol) == -1) { mtevL(mtev_stderr, "I can't understand module %s\n", name); dlclose(dlhandle); return -1; } obj = calloc(1, obj_size); memcpy(obj, dlsymbol, obj_size); obj->opaque_handle = calloc(1, sizeof(struct __extended_image_data)); if(obj->onload && obj->onload(obj)) { free(obj->opaque_handle); free(obj); dlclose(dlhandle); return -1; } char *namecopy = strdup(name); if(!mtev_hash_store(registry, namecopy, strlen(namecopy), obj)) { mtevL(mtev_error, "Attempted to load module %s more than once.\n", name); dlclose(dlhandle); free(namecopy); return -1; } ((struct __extended_image_data *)obj->opaque_handle)->dlhandle = dlhandle; 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; }
static iep_thread_driver_t *noit_fq_allocate(mtev_conf_section_t conf) { char *hostname, *cp, *brk, *round_robin; int i; #define GETCONFSTR(w) mtev_conf_get_stringbuf(conf, #w, global_fq_ctx.w, sizeof(global_fq_ctx.w)) memset(&global_fq_ctx.down_host, 0, sizeof(global_fq_ctx.down_host)); memset(&global_fq_ctx.last_error, 0, sizeof(global_fq_ctx.last_error)); memset(&global_fq_ctx.filtered_exchange, 0, sizeof(global_fq_ctx.filtered_exchange)); snprintf(global_fq_ctx.exchange, sizeof(global_fq_ctx.exchange), "%s", "noit.firehose"); GETCONFSTR(exchange); GETCONFSTR(filtered_exchange); if(!GETCONFSTR(routingkey)) snprintf(global_fq_ctx.routingkey, sizeof(global_fq_ctx.routingkey), "%s", "check"); snprintf(global_fq_ctx.username, sizeof(global_fq_ctx.username), "%s", "guest"); GETCONFSTR(username); snprintf(global_fq_ctx.password, sizeof(global_fq_ctx.password), "%s", "guest"); GETCONFSTR(password); if(!mtev_conf_get_int(conf, "heartbeat", &global_fq_ctx.heartbeat)) global_fq_ctx.heartbeat = 2000; if(!mtev_conf_get_int(conf, "backlog", &global_fq_ctx.backlog)) global_fq_ctx.backlog = 10000; if(!mtev_conf_get_int(conf, "port", &global_fq_ctx.port)) global_fq_ctx.port = 8765; (void)mtev_conf_get_string(conf, "round_robin", &round_robin); if (!round_robin) { global_fq_ctx.round_robin = 0; } else { if (!(strncmp(round_robin, "true", 4))) { global_fq_ctx.round_robin = 1; global_fq_ctx.round_robin_target = 0; } else { global_fq_ctx.round_robin = 0; } } (void)mtev_conf_get_string(conf, "hostname", &hostname); if(!hostname) hostname = strdup("127.0.0.1"); for(cp = hostname; cp; cp = strchr(cp+1, ',')) global_fq_ctx.nhosts++; if(global_fq_ctx.nhosts > MAX_HOSTS) global_fq_ctx.nhosts = MAX_HOSTS; for(i = 0, cp = strtok_r(hostname, ",", &brk); cp; cp = strtok_r(NULL, ",", &brk), i++) { char *pcp; fq_client *c = &global_fq_ctx.client[i]; global_fq_ctx.ports[i] = global_fq_ctx.port; strlcpy(global_fq_ctx.hostname[i], cp, sizeof(global_fq_ctx.hostname[i])); pcp = strchr(global_fq_ctx.hostname[i], ':'); if(pcp) { *pcp++ = '\0'; global_fq_ctx.ports[i] = atoi(pcp); } fq_client_init(c, 0, fq_logger); fq_client_creds(*c, global_fq_ctx.hostname[i], global_fq_ctx.ports[i], global_fq_ctx.username, global_fq_ctx.password); fq_client_heartbeat(*c, global_fq_ctx.heartbeat); fq_client_set_nonblock(*c, 1); fq_client_set_backlog(*c, global_fq_ctx.backlog, 0); fq_client_connect(*c); } free(hostname); return (iep_thread_driver_t *)&global_fq_ctx; }