/*
* _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);
}
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);
}
/*
* _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);
}
