/** * Invoked to when we've reached the flush interval timeout */ void flush_interval_trigger() { // Make a new metrics object metrics *m = malloc(sizeof(metrics)); init_metrics(GLOBAL_CONFIG->timer_eps, GLOBAL_CONFIG->quantiles, GLOBAL_CONFIG->num_quantiles, GLOBAL_CONFIG->histograms, GLOBAL_CONFIG->set_precision, m); // Swap with the new one metrics *old = GLOBAL_METRICS; GLOBAL_METRICS = m; // Start a flush thread pthread_t thread; sigset_t oldset; sigset_t newset; sigfillset(&newset); pthread_sigmask(SIG_BLOCK, &newset, &oldset); int err = pthread_create(&thread, NULL, flush_thread, old); pthread_sigmask(SIG_SETMASK, &oldset, NULL); if (err == 0) { pthread_detach(thread); return; } syslog(LOG_WARNING, "Failed to spawn flush thread: %s", strerror(err)); GLOBAL_METRICS = old; destroy_metrics(m); free(m); }
/****************************************************************************** * * * Function: main * * * * Purpose: executes proxy processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { zbx_task_t task = ZBX_TASK_START; char ch; progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD)) task = ZBX_TASK_CONFIG_CACHE_RELOAD; else { printf("invalid runtime control option: %s\n", zbx_optarg); exit(EXIT_FAILURE); } break; case 'h': help(); exit(-1); break; case 'V': version(); exit(-1); break; default: usage(); exit(-1); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_CONFIG_CACHE_RELOAD == task) exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif return daemon_start(CONFIG_ALLOW_ROOT); }
/****************************************************************************** * * * Function: main * * * * Purpose: executes proxy processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { ZBX_TASK_EX t = {ZBX_TASK_START}; char ch; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (SUCCEED != parse_rtc_options(zbx_optarg, daemon_type, &t.flags)) exit(EXIT_FAILURE); t.task = ZBX_TASK_RUNTIME_CONTROL; break; case 'h': help(); exit(EXIT_SUCCESS); break; case 'V': version(); exit(EXIT_SUCCESS); break; default: usage(); exit(EXIT_FAILURE); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_RUNTIME_CONTROL == t.task) exit(SUCCEED == zbx_sigusr_send(t.flags) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER); }
/** * Invoked to initialize the conn handler layer. */ void init_conn_handler(statsite_config *config) { // Make the initial metrics object metrics *m = malloc(sizeof(metrics)); int res = init_metrics(config->timer_eps, (double*)&QUANTILES, NUM_QUANTILES, m); assert(res == 0); GLOBAL_METRICS = m; // Store the config GLOBAL_CONFIG = config; }
/** * Invoked to initialize the conn handler layer. */ void init_conn_handler(statsite_config *config) { // Make the initial metrics object metrics *m = malloc(sizeof(metrics)); int res = init_metrics(config->timer_eps, config->quantiles, config->num_quantiles, config->histograms, config->set_precision, m); assert(res == 0); GLOBAL_METRICS = m; // Store the config GLOBAL_CONFIG = config; }
/** * Invoked to when we've reached the flush interval timeout */ void flush_interval_trigger() { // Make a new metrics object metrics *m = malloc(sizeof(metrics)); init_metrics(GLOBAL_METRICS->eps, (double*)&QUANTILES, NUM_QUANTILES, m); // Swap with the new one metrics *old = GLOBAL_METRICS; GLOBAL_METRICS = m; // Start a flush thread pthread_t thread; pthread_create(&thread, NULL, flush_thread, old); pthread_detach(thread); }
/** * @name program_editup * * Initialize all the things in the program that need to be initialized. * init_permute determines whether to initialize the permute functions * and Dawg models. */ void Wordrec::program_editup(const char *textbase, bool init_permute) { if (textbase != NULL) { imagefile = textbase; /* Read in data files */ edit_with_ocr(textbase); } /* Initialize subsystems */ program_init(); mfeature_init(); // assumes that imagefile is initialized if (init_permute) getDict().init_permute(); setup_cp_maps(); init_metrics(); pass2_ok_split = chop_ok_split; pass2_seg_states = wordrec_num_seg_states; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Parameters: * * * * Return value: * * * * Author: Eugene Grigorjev * * * * Comments: * * * ******************************************************************************/ int main(int argc, char **argv) { char ch = '\0'; progname = argv[0]; /* Parse the command-line. */ while ((ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts,NULL)) != (char)EOF) switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(-1); break; case 'V': version(); exit(-1); break; default: usage(); exit(-1); break; } if(CONFIG_FILE == NULL) { CONFIG_FILE=strdup("/etc/zabbix/zabbix_proxy.conf"); } /* Required for simple checks */ init_metrics(); init_config(); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif return daemon_start(CONFIG_ALLOW_ROOT); }
int main(int argc, char **argv) { ZBX_TASK_EX t; #ifdef _WINDOWS int ret; /* Provide, so our process handles errors instead of the system itself. */ /* Attention!!! */ /* The system does not display the critical-error-handler message box. */ /* Instead, the system sends the error to the calling process.*/ SetErrorMode(SEM_FAILCRITICALERRORS); #endif #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif memset(&t, 0, sizeof(t)); t.task = ZBX_TASK_START; progname = get_program_name(argv[0]); parse_commandline(argc, argv, &t); import_symbols(); /* this is needed to set default hostname in zbx_load_config() */ init_metrics(); switch (t.task) { case ZBX_TASK_SHOW_USAGE: usage(); exit(EXIT_FAILURE); break; #ifdef _WINDOWS case ZBX_TASK_INSTALL_SERVICE: case ZBX_TASK_UNINSTALL_SERVICE: case ZBX_TASK_START_SERVICE: case ZBX_TASK_STOP_SERVICE: zbx_load_config(ZBX_CFG_FILE_REQUIRED); zbx_free_config(); if (t.flags & ZBX_TASK_FLAG_MULTIPLE_AGENTS) { zbx_snprintf(ZABBIX_SERVICE_NAME, sizeof(ZABBIX_SERVICE_NAME), "%s [%s]", APPLICATION_NAME, CONFIG_HOSTNAME); zbx_snprintf(ZABBIX_EVENT_SOURCE, sizeof(ZABBIX_EVENT_SOURCE), "%s [%s]", APPLICATION_NAME, CONFIG_HOSTNAME); } ret = zbx_exec_service_task(argv[0], &t); free_metrics(); exit(ret); break; #endif case ZBX_TASK_TEST_METRIC: case ZBX_TASK_PRINT_SUPPORTED: zbx_load_config(ZBX_CFG_FILE_OPTIONAL); #ifdef _WINDOWS init_perf_collector(0); load_perf_counters(CONFIG_PERF_COUNTERS); #else zbx_set_common_signal_handlers(); #endif #ifndef _WINDOWS if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 0)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } #endif load_user_parameters(CONFIG_USER_PARAMETERS); load_aliases(CONFIG_ALIASES); zbx_free_config(); if (ZBX_TASK_TEST_METRIC == t.task) test_parameter(TEST_METRIC); else test_parameters(); #ifdef _WINDOWS free_perf_collector(); /* cpu_collector must be freed before perf_collector is freed */ #endif #ifndef _WINDOWS unload_modules(); #endif free_metrics(); alias_list_free(); exit(SUCCEED); break; default: zbx_load_config(ZBX_CFG_FILE_REQUIRED); break; } START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT); exit(SUCCEED); }
int main(int argc, char **argv) { char ch; int task = ZBX_TASK_START; char *TEST_METRIC = NULL; zbx_sock_t s_in; zbx_sock_t s_out; int ret; char **value, *command; AGENT_RESULT result; progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(FAIL); break; case 'V': version(); #ifdef _AIX tl_version(); #endif exit(FAIL); break; case 'p': if (task == ZBX_TASK_START) task = ZBX_TASK_PRINT_SUPPORTED; break; case 't': if (task == ZBX_TASK_START) { task = ZBX_TASK_TEST_METRIC; TEST_METRIC = strdup(zbx_optarg); } break; default: usage(); exit(FAIL); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = DEFAULT_CONFIG_FILE; /* load configuration */ if (ZBX_TASK_PRINT_SUPPORTED == task || ZBX_TASK_TEST_METRIC == task) zbx_load_config(ZBX_CFG_FILE_OPTIONAL); else zbx_load_config(ZBX_CFG_FILE_REQUIRED); /* metrics should be initialized before loading user parameters */ init_metrics(); /* user parameters */ load_user_parameters(CONFIG_USER_PARAMETERS); /* aliases */ load_aliases(CONFIG_ALIASES); zbx_free_config(); /* do not create debug files */ zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL); switch (task) { case ZBX_TASK_TEST_METRIC: case ZBX_TASK_PRINT_SUPPORTED: if (ZBX_TASK_TEST_METRIC == task) test_parameter(TEST_METRIC); else test_parameters(); zabbix_close_log(); free_metrics(); alias_list_free(); exit(SUCCEED); break; default: /* do nothing */ break; } signal(SIGINT, child_signal_handler); signal(SIGTERM, child_signal_handler); signal(SIGQUIT, child_signal_handler); signal(SIGALRM, child_signal_handler); alarm(CONFIG_TIMEOUT); zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin)); zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout)); if (SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0))) { if (SUCCEED == (ret = zbx_tcp_recv(&s_in, &command))) { zbx_rtrim(command, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command); init_result(&result); process(command, 0, &result); if (NULL == (value = GET_TEXT_RESULT(&result))) value = GET_MSG_RESULT(&result); if (NULL != value) { zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value); ret = zbx_tcp_send(&s_out, *value); } free_result(&result); } if (FAIL == ret) zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror()); } fflush(stdout); alarm(0); zabbix_close_log(); free_metrics(); alias_list_free(); return SUCCEED; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { ZBX_TASK_EX t = {ZBX_TASK_START}; char ch, *error = NULL; int opt_c = 0, opt_r = 0; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': opt_c++; if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': opt_r++; if (SUCCEED != parse_rtc_options(zbx_optarg, program_type, &t.data)) exit(EXIT_FAILURE); t.task = ZBX_TASK_RUNTIME_CONTROL; break; case 'h': help(); exit(EXIT_SUCCESS); break; case 'V': version(); exit(EXIT_SUCCESS); break; case 'f': t.flags |= ZBX_TASK_FLAG_FOREGROUND; break; default: usage(); exit(EXIT_FAILURE); break; } } /* every option may be specified only once */ if (1 < opt_c || 1 < opt_r) { if (1 < opt_c) zbx_error("option \"-c\" or \"--config\" specified multiple times"); if (1 < opt_r) zbx_error("option \"-R\" or \"--runtime-control\" specified multiple times"); exit(EXIT_FAILURE); } /* Parameters which are not option values are invalid. The check relies on zbx_getopt_internal() which */ /* always permutes command line arguments regardless of POSIXLY_CORRECT environment variable. */ if (argc > zbx_optind) { int i; for (i = zbx_optind; i < argc; i++) zbx_error("invalid parameter \"%s\"", argv[i]); exit(EXIT_FAILURE); } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(NULL, DEFAULT_CONFIG_FILE); /* required for simple checks */ init_metrics(); zbx_load_config(&t); if (ZBX_TASK_RUNTIME_CONTROL == t.task) exit(SUCCEED == zbx_sigusr_send(t.data) ? EXIT_SUCCESS : EXIT_FAILURE); zbx_initialize_events(); if (FAIL == zbx_ipc_service_init_env(CONFIG_SOCKET_PATH, &error)) { zbx_error("Cannot initialize IPC services: %s", error); zbx_free(error); exit(EXIT_FAILURE); } return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER, t.flags); }
/** * Initializes the metrics struct, with preset configurations. * This defaults to a epsilon of 0.01 (1% error), and quantiles at * 0.5, 0.95, and 0.99. * @return 0 on success. */ int init_metrics_defaults(metrics *m) { double quants[] = {0.5, 0.95, 0.99}; return init_metrics(0.01, (double*)&quants, 3, m); }
int main(int argc, char **argv) { char ch; int task = ZBX_TASK_START; char *TEST_METRIC = NULL; zbx_sock_t s_in; zbx_sock_t s_out; int ret; char **value, *command; AGENT_RESULT result; memset(&result, 0, sizeof(AGENT_RESULT)); progname = get_program_name(argv[0]); /* Parse the command-line. */ while ((ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)) != (char)EOF) switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(-1); break; case 'V': version(); #ifdef _AIX tl_version(); #endif /* _AIX */ exit(-1); break; case 'p': if (task == ZBX_TASK_START) task = ZBX_TASK_PRINT_SUPPORTED; break; case 't': if (task == ZBX_TASK_START) { task = ZBX_TASK_TEST_METRIC; TEST_METRIC = strdup(zbx_optarg); } break; default: task = ZBX_TASK_SHOW_USAGE; break; } if (CONFIG_FILE == NULL) CONFIG_FILE = DEFAULT_CONFIG_FILE; init_metrics(); if (ZBX_TASK_START == task) { load_config(); load_user_parameters(0); } /* Do not create debug files */ zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL); switch (task) { case ZBX_TASK_PRINT_SUPPORTED: load_user_parameters(1); test_parameters(); exit(-1); break; case ZBX_TASK_TEST_METRIC: load_user_parameters(1); test_parameter(TEST_METRIC, PROCESS_TEST); exit(-1); break; case ZBX_TASK_SHOW_USAGE: usage(); exit(-1); break; } signal(SIGINT, child_signal_handler); signal(SIGTERM, child_signal_handler); signal(SIGQUIT, child_signal_handler); signal(SIGALRM, child_signal_handler); alarm(CONFIG_TIMEOUT); zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin)); zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout)); if( SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)) ) { if( SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)) ) { zbx_rtrim(command, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command); init_result(&result); process(command, 0, &result); if( NULL == (value = GET_TEXT_RESULT(&result)) ) value = GET_MSG_RESULT(&result); if(value) { zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value); ret = zbx_tcp_send(&s_out, *value); } free_result(&result); } if( FAIL == ret ) { zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror()); } } fflush(stdout); free_metrics(); alias_list_free(); alarm(0); zabbix_close_log(); return SUCCEED; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { zbx_task_t task = ZBX_TASK_START; char ch = '\0'; int nodeid = 0; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD)) task = ZBX_TASK_CONFIG_CACHE_RELOAD; else { printf("invalid runtime control option: %s\n", zbx_optarg); exit(EXIT_FAILURE); } break; case 'h': help(); exit(-1); break; case 'n': nodeid = (NULL == zbx_optarg ? 0 : atoi(zbx_optarg)); task = ZBX_TASK_CHANGE_NODEID; break; case 'V': version(); exit(-1); break; default: usage(); exit(-1); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_server.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_CONFIG_CACHE_RELOAD == task) exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif switch (task) { case ZBX_TASK_CHANGE_NODEID: exit(SUCCEED == change_nodeid(nodeid) ? EXIT_SUCCESS : EXIT_FAILURE); break; default: break; } return daemon_start(CONFIG_ALLOW_ROOT); }