/* * _metric_list * * Output list of all available metrics */ static void _metric_list(void) { const char *func = __FUNCTION__; cerebro_namelist_t m = NULL; cerebro_namelist_iterator_t mitr = NULL; List l = NULL; ListIterator litr = NULL; char *str; if (!(m = cerebro_get_metric_names(handle))) { char *msg = cerebro_strerror(cerebro_errnum(handle)); _clean_err_exit(cerebro_errnum(handle)); err_exit("%s: cerebro_get_metric_names: %s", func, msg); } if (!(mitr = cerebro_namelist_iterator_create(m))) { char *msg = cerebro_strerror(cerebro_namelist_errnum(m)); err_exit("%s: cerebro_namelist_iterator_create: %s", func, msg); } l = List_create(NULL); while (!cerebro_namelist_iterator_at_end(mitr)) { if (cerebro_namelist_iterator_name(mitr, &str) < 0) { char *msg = cerebro_strerror(cerebro_namelist_iterator_errnum(mitr)); err_exit("%s: cerebro_namelist_iterator_name: %s", func, msg); } List_append(l, str); if (cerebro_namelist_iterator_next(mitr) < 0) { char *msg = cerebro_strerror(cerebro_namelist_iterator_errnum(mitr)); err_exit("%s: cerebro_namelist_iterator_next: %s", func, msg); } } litr = List_iterator_create(l); while ((str = list_next(litr))) fprintf(stdout, "%s\n", str); /* List_destroy() and cerebro_namelist_destory() destroy iterators too */ List_destroy(l); (void)cerebro_namelist_destroy(m); }
static int _get_metric_data (cerebro_t ch, char *name, List rl) { int retval; cerebro_nodelist_t n = NULL; cerebro_nodelist_iterator_t nitr; cmetric_t c; unsigned int time, type, size; void *value; char *nodename; if (!(n = cerebro_get_metric_data (ch, name))) { if (lmt_conf_get_cbr_debug ()) msg ("error getting metric data for %s: %s", name, cerebro_strerror (cerebro_errnum (ch))); goto done; } if (!(nitr = cerebro_nodelist_iterator_create (n))) { if (lmt_conf_get_cbr_debug ()) msg ("error creating nodelist iterator for %s metric data: %s", name, cerebro_strerror (cerebro_errnum (ch))); goto done; } while (!cerebro_nodelist_iterator_at_end (nitr)) { if (cerebro_nodelist_iterator_nodename (nitr, &nodename) < 0 || cerebro_nodelist_iterator_metric_value (nitr, &time, &type, &size, &value) < 0) { if (lmt_conf_get_cbr_debug ()) msg ("error retrieving metric value for %s: %s", name, cerebro_strerror (cerebro_nodelist_iterator_errnum (nitr))); goto done; } c = _create_cmetric (name, nodename, time, type, size, value); if (!(list_append (rl, c))) { _destroy_cmetric (c); goto done; } if (cerebro_nodelist_iterator_next (nitr) < 0) { if (lmt_conf_get_cbr_debug ()) msg ("error iterating on metric %s: %s", name, cerebro_strerror (cerebro_nodelist_iterator_errnum (nitr))); goto done; } } retval = 0; done: if (n) cerebro_nodelist_destroy (n); /* side effect: destroys nitr */ return retval; }
int main(int argc, char *argv[]) { const char *func = __FUNCTION__; int rv = 0; err_init(argv[0]); err_set_flags(ERROR_STDERR); #if CEREBRO_DEBUG cerebro_err_init(argv[0]); #endif /* CEREBRO_DEBUG */ _init_cerebro_admin(); _cmdline_parse(argc, argv); if (operation == CEREBRO_ADMIN_REGISTER) rv = cerebro_register_metric(handle, metric_name); else if (operation == CEREBRO_ADMIN_UNREGISTER) rv = cerebro_unregister_metric(handle, metric_name); else if (operation == CEREBRO_ADMIN_UPDATE) rv = cerebro_update_metric_value(handle, metric_name, metric_value_type, metric_value_len, metric_value_ptr); else if (operation == CEREBRO_ADMIN_RESEND) rv = cerebro_resend_metric(handle, metric_name); else if (operation == CEREBRO_ADMIN_FLUSH) rv = cerebro_flush_metric(handle, metric_name); if (rv < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); _clean_err_exit(cerebro_errnum(handle)); err_exit("%s: %s", func, msg); } _cleanup_cerebro_stat(); exit(0); }
/* * _cerebro_set_flags * * Set a cerebro flag */ static void _cerebro_set_flags(unsigned int new_flag) { const char *func = __FUNCTION__; int flags; if ((flags = cerebro_get_flags(handle)) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); err_exit("%s: cerebro_get_flags: %s", func, msg); } flags |= new_flag; if (cerebro_set_flags(handle, flags) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); err_exit("%s: cerebro_set_flags: %s", func, msg); } }
/* * _metric_data * * Output list of all available metrics */ static void _metric_data(void) { const char *func = __FUNCTION__; cerebro_nodelist_t n = NULL; cerebro_nodelist_iterator_t nitr = NULL; List l = NULL; if (!(n = cerebro_get_metric_data(handle, metric_name))) { char *msg = cerebro_strerror(cerebro_errnum(handle)); _clean_err_exit(cerebro_errnum(handle)); err_exit("%s: cerebro_get_metric_data: %s", func, msg); } if (!(nitr = cerebro_nodelist_iterator_create(n))) { char *msg = cerebro_strerror(cerebro_nodelist_errnum(n)); err_exit("%s: cerebro_nodelist_iterator_create: %s", func, msg); } l = List_create((ListDelF)_Free); while (!cerebro_nodelist_iterator_at_end(nitr)) { struct node_metric_data *data = NULL; data = Malloc(sizeof(struct node_metric_data)); memset(data, '\0', sizeof(struct node_metric_data)); if (cerebro_nodelist_iterator_nodename(nitr, &(data->nodename)) < 0) { char *msg = cerebro_strerror(cerebro_nodelist_iterator_errnum(nitr)); err_exit("%s: cerebro_nodelist_iterator_nodename: %s", func, msg); } if (cerebro_nodelist_iterator_metric_value(nitr, &(data->metric_value_received_time), &(data->metric_value_type), &(data->metric_value_len), &(data->metric_value)) < 0) { char *msg = cerebro_strerror(cerebro_nodelist_iterator_errnum(nitr)); err_exit("%s: cerebro_nodelist_iterator_metric_value: %s", func, msg); } List_append(l, data); if (cerebro_nodelist_iterator_next(nitr) < 0) { char *msg = cerebro_strerror(cerebro_nodelist_iterator_errnum(nitr)); err_exit("%s: cerebro_nodelist_iterator_next: %s", func, msg); } } if (!strcmp(metric_name, CEREBRO_METRIC_CLUSTER_NODES)) _cluster_nodes_output(l); else if (output_type == CEREBRO_STAT_NEWLINE) _newline_output(l); else if (output_type == CEREBRO_STAT_HOSTRANGE) _hostrange_output(l); /* List_destroy() and cerebro_nodelist_destory() destroy iterators too */ List_destroy(l); (void)cerebro_nodelist_destroy(n); }
/* * _event_data * * Monitor event data */ static void _event_data(void) { const char *func = __FUNCTION__; int fd; if ((fd = cerebro_event_register(handle, event_name)) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); _clean_err_exit(cerebro_errnum(handle)); err_exit("%s: cerebro_event_register: %s", func, msg); } while (1) { struct pollfd pfd; int n; pfd.fd = fd; pfd.events = POLLIN; pfd.revents = 0; n = Poll(&pfd, 1, -1); if (n && pfd.revents & POLLIN) { char vbuf[CEREBRO_STAT_BUFLEN]; char tbuf[CEREBRO_STAT_BUFLEN]; char *nodename; unsigned int event_value_type; unsigned int event_value_len; void *event_value; time_t t; struct tm *tm; if (cerebro_event_parse(handle, fd, &nodename, &event_value_type, &event_value_len, &event_value) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); _clean_err_exit(cerebro_errnum(handle)); err_exit("%s: cerebro_event_parse: %s", func, msg); } memset(vbuf, '\0', CEREBRO_STAT_BUFLEN); _metric_value_str(event_value_type, event_value_len, event_value, vbuf, CEREBRO_STAT_BUFLEN); memset(tbuf, '\0', CEREBRO_STAT_BUFLEN); t = time(NULL); tm = Localtime(&t); strftime(tbuf, CEREBRO_STAT_BUFLEN, "%F %I:%M:%S%P", tm); fprintf(stdout, "%s(%s): %s\n", nodename, tbuf, vbuf); free(nodename); free(event_value); } } (void)cerebro_event_unregister(handle, fd); }
/* * _cmdline_parse * * parse all cmdline input */ static void _cmdline_parse(int argc, char **argv) { const char *func = __FUNCTION__; char options[1024]; char *ptr; int c; #if HAVE_GETOPT_LONG struct option loptions[] = { {"help", 0, NULL, 'h'}, {"version", 0, NULL, 'v'}, {"hostname", 1, NULL, 'o'}, {"port", 1, NULL, 'p'}, {"metric", 1, NULL, 'm'}, {"metric-list", 0, NULL, 'l'}, {"up-only", 0, NULL, 'U'}, {"none-if-down", 0, NULL, 'D'}, {"none-if-not-monitored", 0, NULL, 'N'}, {"newline", 0, NULL, 'n'}, {"hostrange", 0, NULL, 'q'}, {"metric-received-time", 0, NULL, 't'}, {"event", 1, NULL, 'e'}, {"event-list", 0, NULL, 'z'}, #if CEREBRO_DEBUG {"debug", 0, NULL, 'd'}, #endif /* CEREBRO_DEBUG */ {0, 0, 0, 0}, }; #endif /* HAVE_GETOPT_LONG */ assert(argv); strcpy(options, "hvo:p:ze:lm:UDNnqt"); #if CEREBRO_DEBUG strcat(options, "d"); #endif /* CEREBRO_DEBUG */ /* turn off output messages printed by getopt_long */ opterr = 0; #if HAVE_GETOPT_LONG while ((c = getopt_long(argc, argv, options, loptions, NULL)) != -1) #else while ((c = getopt(argc, argv, options)) != -1) #endif { switch(c) { case 'h': _usage(); case 'v': _version(); case 'o': hostname = optarg; if (cerebro_set_hostname(handle, hostname) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); err_exit("%s: cerebro_set_hostname: %s", func, msg); } break; case 'p': port = strtol(optarg, &ptr, 10); if (ptr != (optarg + strlen(optarg))) err_exit("invalid port specified"); if (cerebro_set_port(handle, port) < 0) { char *msg = cerebro_strerror(cerebro_errnum(handle)); err_exit("%s: cerebro_set_port: %s", func, msg); } break; case 'm': metric_name = optarg; break; case 'l': metric_list_flag++; break; case 'U': _cerebro_set_flags(CEREBRO_METRIC_DATA_FLAGS_UP_ONLY); break; case 'D': _cerebro_set_flags(CEREBRO_METRIC_DATA_FLAGS_NONE_IF_DOWN); break; case 'N': _cerebro_set_flags(CEREBRO_METRIC_DATA_FLAGS_NONE_IF_NOT_MONITORED); break; case 'n': output_type = CEREBRO_STAT_NEWLINE; break; case 'q': output_type = CEREBRO_STAT_HOSTRANGE; break; case 't': metric_received_time_flag++; break; case 'e': event_name = optarg; break; case 'z': event_list_flag++; break; #if CEREBRO_DEBUG case 'd': cerebro_err_set_flags(CEREBRO_ERROR_STDERR); break; #endif /* CEREBRO_DEBUG */ default: case '?': fprintf(stderr, "command line option error\n"); _usage(); } } if (((metric_list_flag ? 1 : 0) + (metric_name ? 1 : 0) + (event_name ? 1 : 0) + (event_list_flag ? 1 : 0)) > 1) err_exit("Specify one of --event-list, --event, --metric-list, and --metric options"); if (!event_name && !event_list_flag && !metric_list_flag && !metric_name) _usage(); }