int read_types_list (const char *file)
{
FILE *fh;
if (file == NULL)
return (-1);
fh = fopen (file, "r");
if (fh == NULL)
{
char errbuf[1024];
fprintf (stderr, "Failed to open types database `%s': %s.\n",
file, sstrerror (errno, errbuf, sizeof (errbuf)));
ERROR ("Failed to open types database `%s': %s",
file, sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
parse_file (fh);
fclose (fh);
fh = NULL;
DEBUG ("Done parsing `%s'", file);
return (0);
} /* int read_types_list */
static char *camqp_strerror (camqp_config_t *conf, /* {{{ */
char *buffer, size_t buffer_size)
{
amqp_rpc_reply_t r;
r = amqp_get_rpc_reply (conf->connection);
switch (r.reply_type)
{
case AMQP_RESPONSE_NORMAL:
sstrncpy (buffer, "Success", sizeof (buffer));
break;
case AMQP_RESPONSE_NONE:
sstrncpy (buffer, "Missing RPC reply type", sizeof (buffer));
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
#if HAVE_AMQP_RPC_REPLY_T_LIBRARY_ERRNO
if (r.library_errno)
return (sstrerror (r.library_errno, buffer, buffer_size));
#else
if (r.library_error)
return (sstrerror (r.library_error, buffer, buffer_size));
#endif
else
sstrncpy (buffer, "End of stream", sizeof (buffer));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
if (r.reply.id == AMQP_CONNECTION_CLOSE_METHOD)
{
amqp_connection_close_t *m = r.reply.decoded;
char *tmp = camqp_bytes_cstring (&m->reply_text);
ssnprintf (buffer, buffer_size, "Server connection error %d: %s",
m->reply_code, tmp);
sfree (tmp);
}
else if (r.reply.id == AMQP_CHANNEL_CLOSE_METHOD)
{
amqp_channel_close_t *m = r.reply.decoded;
char *tmp = camqp_bytes_cstring (&m->reply_text);
ssnprintf (buffer, buffer_size, "Server channel error %d: %s",
m->reply_code, tmp);
sfree (tmp);
}
else
{
ssnprintf (buffer, buffer_size, "Server error method %#"PRIx32,
r.reply.id);
}
break;
default:
ssnprintf (buffer, buffer_size, "Unknown reply type %i",
(int) r.reply_type);
}
return (buffer);
} /* }}} char *camqp_strerror */
static int dpdk_event_keep_alive_shm_open(void) {
dpdk_events_ctx_t *ec = DPDK_EVENTS_CTX_GET(g_hc);
char *shm_name;
if (strlen(ec->config.keep_alive.shm_name)) {
shm_name = ec->config.keep_alive.shm_name;
} else {
shm_name = RTE_KEEPALIVE_SHM_NAME;
WARNING(DPDK_EVENTS_PLUGIN ": Keep alive shared memory identifier is not "
"specified, using default one: %s",
shm_name);
}
char errbuf[ERR_BUF_SIZE];
int fd = shm_open(shm_name, O_RDONLY, 0);
if (fd < 0) {
ERROR(DPDK_EVENTS_PLUGIN ": Failed to open %s as SHM:%s. Is DPDK KA "
"primary application running?",
shm_name, sstrerror(errno, errbuf, sizeof(errbuf)));
return errno;
}
if (ec->config.keep_alive.fd != -1) {
struct stat stat_old, stat_new;
if (fstat(ec->config.keep_alive.fd, &stat_old) || fstat(fd, &stat_new)) {
ERROR(DPDK_EVENTS_PLUGIN ": failed to get information about a file");
close(fd);
return -1;
}
/* Check if inode number has changed. If yes, then create a new mapping */
if (stat_old.st_ino == stat_new.st_ino) {
close(fd);
return 0;
}
if (munmap(ec->config.keep_alive.shm, sizeof(dpdk_keepalive_shm_t)) != 0) {
ERROR(DPDK_EVENTS_PLUGIN ": munmap KA monitor failed");
close(fd);
return -1;
}
close(ec->config.keep_alive.fd);
ec->config.keep_alive.fd = -1;
}
ec->config.keep_alive.shm = (dpdk_keepalive_shm_t *)mmap(
0, sizeof(*(ec->config.keep_alive.shm)), PROT_READ, MAP_SHARED, fd, 0);
if (ec->config.keep_alive.shm == MAP_FAILED) {
ERROR(DPDK_EVENTS_PLUGIN ": Failed to mmap KA SHM:%s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
return errno;
}
ec->config.keep_alive.fd = fd;
return 0;
}
/*
* Open a TCP connection to the UPS network server
* Returns -1 on error
* Returns socket file descriptor otherwise
*/
static int net_open (char const *node, char const *service)
{
int sd;
int status;
struct addrinfo *ai_return;
struct addrinfo *ai_list;
/* TODO: Change this to `AF_UNSPEC' if apcupsd can handle IPv6 */
struct addrinfo ai_hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM
};
status = getaddrinfo (node, service, &ai_hints, &ai_return);
if (status != 0)
{
char errbuf[1024];
INFO ("apcups plugin: getaddrinfo failed: %s",
(status == EAI_SYSTEM)
? sstrerror (errno, errbuf, sizeof (errbuf))
: gai_strerror (status));
return (-1);
}
/* Create socket */
sd = -1;
for (ai_list = ai_return; ai_list != NULL; ai_list = ai_list->ai_next)
{
sd = socket (ai_list->ai_family, ai_list->ai_socktype, ai_list->ai_protocol);
if (sd >= 0)
break;
}
/* `ai_list' still holds the current description of the socket.. */
if (sd < 0)
{
DEBUG ("apcups plugin: Unable to open a socket");
freeaddrinfo (ai_return);
return (-1);
}
status = connect (sd, ai_list->ai_addr, ai_list->ai_addrlen);
freeaddrinfo (ai_return);
if (status != 0) /* `connect(2)' failed */
{
char errbuf[1024];
INFO ("apcups plugin: connect failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
close (sd);
return (-1);
}
DEBUG ("apcups plugin: Done opening a socket %i", sd);
return (sd);
} /* int net_open */
static int zookeeper_connect (void)
{
int sk = -1;
int status;
struct addrinfo *ai;
struct addrinfo *ai_list;
const char *host;
const char *port;
host = (zk_host != NULL) ? zk_host : ZOOKEEPER_DEF_HOST;
port = (zk_port != NULL) ? zk_port : ZOOKEEPER_DEF_PORT;
struct addrinfo ai_hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_STREAM
};
status = getaddrinfo (host, port, &ai_hints, &ai_list);
if (status != 0)
{
char errbuf[1024];
INFO ("getaddrinfo failed: %s",
(status == EAI_SYSTEM)
? sstrerror (errno, errbuf, sizeof (errbuf))
: gai_strerror (status));
return (-1);
}
for (ai = ai_list; ai != NULL; ai = ai->ai_next)
{
sk = socket (ai->ai_family, SOCK_STREAM, 0);
if (sk < 0)
{
char errbuf[1024];
WARNING ("zookeeper: socket(2) failed: %s",
sstrerror (errno, errbuf, sizeof(errbuf)));
continue;
}
status = (int) connect (sk, ai->ai_addr, ai->ai_addrlen);
if (status != 0)
{
char errbuf[1024];
close (sk);
sk = -1;
WARNING ("zookeeper: connect(2) failed: %s",
sstrerror (errno, errbuf, sizeof(errbuf)));
continue;
}
/* connected */
break;
}
freeaddrinfo(ai_list);
return (sk);
} /* int zookeeper_connect */
static int memcached_connect_inet (memcached_t *st)
{
struct addrinfo *ai_list;
int status;
int fd = -1;
struct addrinfo ai_hints = {
.ai_family = AF_UNSPEC,
.ai_flags = AI_ADDRCONFIG,
.ai_socktype = SOCK_STREAM
};
status = getaddrinfo (st->connhost, st->connport, &ai_hints, &ai_list);
if (status != 0)
{
char errbuf[1024];
ERROR ("memcached plugin: memcached_connect_inet: "
"getaddrinfo(%s,%s) failed: %s",
st->connhost, st->connport,
(status == EAI_SYSTEM)
? sstrerror (errno, errbuf, sizeof (errbuf))
: gai_strerror (status));
return (-1);
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* create our socket descriptor */
fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (fd < 0)
{
char errbuf[1024];
WARNING ("memcached plugin: memcached_connect_inet: "
"socket(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
continue;
}
/* connect to the memcached daemon */
status = (int) connect (fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
if (status != 0)
{
shutdown (fd, SHUT_RDWR);
close (fd);
fd = -1;
continue;
}
/* A socket could be opened and connecting succeeded. We're done. */
break;
}
freeaddrinfo (ai_list);
return (fd);
} /* int memcached_connect_inet */
static int nagios_print(char const *buffer) /* {{{ */
{
char const *file = NAGIOS_COMMAND_FILE;
int fd;
int status;
struct flock lock = {0};
if (nagios_command_file != NULL)
file = nagios_command_file;
fd = open(file, O_WRONLY | O_APPEND);
if (fd < 0) {
char errbuf[1024];
status = errno;
ERROR("notify_nagios plugin: Opening \"%s\" failed: %s", file,
sstrerror(status, errbuf, sizeof(errbuf)));
return status;
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_END;
status = fcntl(fd, F_GETLK, &lock);
if (status != 0) {
char errbuf[1024];
status = errno;
ERROR("notify_nagios plugin: Failed to acquire write lock on \"%s\": %s",
file, sstrerror(status, errbuf, sizeof(errbuf)));
close(fd);
return status;
}
status = (int)lseek(fd, 0, SEEK_END);
if (status == -1) {
char errbuf[1024];
status = errno;
ERROR("notify_nagios plugin: Seeking to end of \"%s\" failed: %s", file,
sstrerror(status, errbuf, sizeof(errbuf)));
close(fd);
return status;
}
status = (int)swrite(fd, buffer, strlen(buffer));
if (status != 0) {
char errbuf[1024];
status = errno;
ERROR("notify_nagios plugin: Writing to \"%s\" failed: %s", file,
sstrerror(status, errbuf, sizeof(errbuf)));
close(fd);
return status;
}
close(fd);
return status;
} /* }}} int nagios_print */
static int pf_read (void)
{
struct pf_status state;
int fd;
int status;
int i;
fd = open (pf_device, O_RDONLY);
if (fd < 0)
{
char errbuf[1024];
ERROR("pf plugin: Unable to open %s: %s",
pf_device,
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
memset (&state, 0, sizeof (state));
status = ioctl (fd, DIOCGETSTATUS, &state);
if (status != 0)
{
char errbuf[1024];
ERROR("pf plugin: ioctl(DIOCGETSTATUS) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
close(fd);
return (-1);
}
close (fd);
fd = -1;
if (!state.running)
{
WARNING ("pf plugin: PF is not running.");
return (-1);
}
for (i = 0; i < PFRES_MAX; i++)
pf_submit ("pf_counters", pf_reasons[i], state.counters[i],
/* is gauge = */ 0);
for (i = 0; i < LCNT_MAX; i++)
pf_submit ("pf_limits", pf_lcounters[i], state.lcounters[i],
/* is gauge = */ 0);
for (i = 0; i < FCNT_MAX; i++)
pf_submit ("pf_state", pf_fcounters[i], state.fcounters[i],
/* is gauge = */ 0);
for (i = 0; i < SCNT_MAX; i++)
pf_submit ("pf_source", pf_scounters[i], state.scounters[i],
/* is gauge = */ 0);
pf_submit ("pf_states", "current", (uint32_t) state.states,
/* is gauge = */ 1);
return (0);
} /* int pf_read */
static int zookeeper_query (char *buffer, size_t buffer_size)
{
int sk = -1;
int status;
size_t buffer_fill;
sk = zookeeper_connect();
if (sk < 0)
{
ERROR ("zookeeper: Could not connect to daemon");
return (-1);
}
status = (int) swrite (sk, "mntr\r\n", strlen("mntr\r\n"));
if (status != 0)
{
char errbuf[1024];
ERROR ("zookeeper: write(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
close (sk);
return (-1);
}
memset (buffer, 0, buffer_size);
buffer_fill = 0;
while ((status = (int) recv (sk, buffer + buffer_fill,
buffer_size - buffer_fill, /* flags = */ 0)) != 0)
{
if (status < 0)
{
char errbuf[1024];
if ((errno == EAGAIN) || (errno == EINTR))
continue;
ERROR ("zookeeper: Error reading from socket: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
close (sk);
return (-1);
}
buffer_fill += (size_t) status;
} /* while (recv) */
status = 0;
if (buffer_fill == 0)
{
WARNING ("zookeeper: No data returned by MNTR command.");
status = -1;
}
close(sk);
return (status);
} /* int zookeeper_query */
static int fhcount_read(void) {
int numfields = 0;
int buffer_len = 60;
gauge_t used, unused, max;
int prc_used, prc_unused;
char *fields[3];
char buffer[buffer_len];
char errbuf[1024];
FILE *fp;
// Open file
fp = fopen("/proc/sys/fs/file-nr" , "r");
if (fp == NULL) {
ERROR("fhcount: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
return(EXIT_FAILURE);
}
if (fgets(buffer, buffer_len, fp) == NULL) {
ERROR("fhcount: fgets: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
return(EXIT_FAILURE);
}
fclose(fp);
// Tokenize string
numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
if (numfields != 3) {
ERROR("fhcount: Line doesn't contain 3 fields");
return(EXIT_FAILURE);
}
// Define the values
strtogauge(fields[0], &used);
strtogauge(fields[1], &unused);
strtogauge(fields[2], &max);
prc_used = (gauge_t) used/max*100;
prc_unused = (gauge_t) unused/max*100;
// Submit values
if (values_absolute) {
fhcount_submit("file_handles", "used", (gauge_t) used);
fhcount_submit("file_handles", "unused", (gauge_t) unused);
fhcount_submit("file_handles", "max", (gauge_t) max);
}
if (values_percentage) {
fhcount_submit("percent", "used", (gauge_t) prc_used);
fhcount_submit("percent", "unused", (gauge_t) prc_unused);
}
return(0);
}
/* Reads a file which contains only a number (and optionally a trailing
* newline) and parses that number. */
static int sysfs_file_to_buffer(char const *dir, /* {{{ */
char const *power_supply,
char const *basename,
char *buffer, size_t buffer_size)
{
int status;
FILE *fp;
char filename[PATH_MAX];
ssnprintf (filename, sizeof (filename), "%s/%s/%s",
dir, power_supply, basename);
/* No file isn't the end of the world -- not every system will be
* reporting the same set of statistics */
if (access (filename, R_OK) != 0)
return ENOENT;
fp = fopen (filename, "r");
if (fp == NULL)
{
status = errno;
if (status != ENOENT)
{
char errbuf[1024];
WARNING ("battery plugin: fopen (%s) failed: %s", filename,
sstrerror (status, errbuf, sizeof (errbuf)));
}
return status;
}
if (fgets (buffer, buffer_size, fp) == NULL)
{
status = errno;
if (status != ENODEV)
{
char errbuf[1024];
WARNING ("battery plugin: fgets (%s) failed: %s", filename,
sstrerror (status, errbuf, sizeof (errbuf)));
}
fclose (fp);
return status;
}
strstripnewline (buffer);
fclose (fp);
return 0;
} /* }}} int sysfs_file_to_buffer */
static int setup_socket (const char *path) {
struct sockaddr_un sa;
int status;
unlink(path);
int sock_fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock_fd < 0) {
char errbuf[1024];
ERROR ("aggregator plugin: socket failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
memset (&sa, '\0', sizeof (sa));
sa.sun_family = AF_UNIX;
sstrncpy (sa.sun_path, (path != NULL) ? path : DEFAULT_SOCK_FILE,
sizeof (sa.sun_path));
/* unlink (sa.sun_path); */
DEBUG ("aggregator plugin: socket path = %s", sa.sun_path);
status = bind (sock_fd, (struct sockaddr *) &sa, sizeof (sa));
if (status != 0)
{
char errbuf[1024];
sstrerror (errno, errbuf, sizeof (errbuf));
ERROR ("aggregator plugin: bind failed: %s", errbuf);
close (sock_fd);
sock_fd = -1;
return (-1);
}
chmod (sa.sun_path, sock_perms);
status = listen (sock_fd, 8);
if (status != 0)
{
char errbuf[1024];
ERROR ("aggregator plugin: listen failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
close (sock_fd);
sock_fd = -1;
return (-1);
}
return sock_fd;
}
static int wg_send_buffer (struct wg_callback *cb)
{
ssize_t status = 0;
status = swrite (cb->sock_fd, cb->send_buf, strlen (cb->send_buf));
if (status < 0)
{
const char *protocol = cb->protocol ? cb->protocol : WG_DEFAULT_PROTOCOL;
if (cb->log_send_errors)
{
char errbuf[1024];
ERROR ("write_graphite plugin: send to %s:%s (%s) failed with status %zi (%s)",
cb->node, cb->service, protocol,
status, sstrerror (errno, errbuf, sizeof (errbuf)));
}
close (cb->sock_fd);
cb->sock_fd = -1;
return (-1);
}
return (0);
}
static int tbl_config_append_array_i (char *name, int **var, size_t *len,
oconfig_item_t *ci)
{
int *tmp;
size_t i;
if (1 > ci->values_num) {
log_err ("\"%s\" expects at least one argument.", name);
return 1;
}
for (i = 0; i < ci->values_num; ++i) {
if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
log_err ("\"%s\" expects numerical arguments only.", name);
return 1;
}
}
*len += ci->values_num;
tmp = (int *)realloc (*var, *len * sizeof (**var));
if (NULL == tmp) {
char errbuf[1024];
log_err ("realloc failed: %s.",
sstrerror (errno, errbuf, sizeof (errbuf)));
return -1;
}
*var = tmp;
for (i = *len - ci->values_num; i < *len; ++i)
(*var)[i] = (int)ci->values[i].value.number;
return 0;
} /* tbl_config_append_array_s */
int read_types_list (const char *file)
{
FILE *fh;
if (file == NULL)
return (-1);
fh = fopen (file, "r");
if (fh == NULL)
{
char errbuf[1024];
ERROR ("open (%s) failed: %s",
file, sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
parse_file (fh);
fclose (fh);
fh = NULL;
DEBUG ("Done parsing `%s'", file);
return (0);
} /* int read_types_list */
static int csv_create_file (const char *filename, const data_set_t *ds)
{
FILE *csv;
int i;
if (check_create_dir (filename))
return (-1);
csv = fopen (filename, "w");
if (csv == NULL)
{
char errbuf[1024];
ERROR ("csv plugin: fopen (%s) failed: %s",
filename,
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
fprintf (csv, "epoch");
for (i = 0; i < ds->ds_num; i++)
fprintf (csv, ",%s", ds->ds[i].name);
fprintf (csv, "\n");
fclose (csv);
return 0;
} /* int csv_create_file */
static void *mc_receive_thread (void *arg) /* {{{ */
{
socket_entry_t *mc_receive_socket_entries;
int status;
size_t i;
mc_receive_socket_entries = NULL;
status = create_sockets (&mc_receive_socket_entries, &mc_receive_sockets_num,
(mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT,
(mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT,
/* listen = */ 1);
if (status != 0)
{
ERROR ("gmond plugin: create_sockets failed.");
return ((void *) -1);
}
mc_receive_sockets = (struct pollfd *) calloc (mc_receive_sockets_num,
sizeof (*mc_receive_sockets));
if (mc_receive_sockets == NULL)
{
ERROR ("gmond plugin: calloc failed.");
for (i = 0; i < mc_receive_sockets_num; i++)
close (mc_receive_socket_entries[i].fd);
free (mc_receive_socket_entries);
mc_receive_socket_entries = NULL;
mc_receive_sockets_num = 0;
return ((void *) -1);
}
for (i = 0; i < mc_receive_sockets_num; i++)
{
mc_receive_sockets[i].fd = mc_receive_socket_entries[i].fd;
mc_receive_sockets[i].events = POLLIN | POLLPRI;
mc_receive_sockets[i].revents = 0;
}
while (mc_receive_thread_loop != 0)
{
status = poll (mc_receive_sockets, mc_receive_sockets_num, -1);
if (status <= 0)
{
char errbuf[1024];
if (errno == EINTR)
continue;
ERROR ("gmond plugin: poll failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
break;
}
for (i = 0; i < mc_receive_sockets_num; i++)
{
if (mc_receive_sockets[i].revents != 0)
mc_handle_socket (mc_receive_sockets + i);
}
} /* while (mc_receive_thread_loop != 0) */
free (mc_receive_socket_entries);
return ((void *) 0);
} /* }}} void *mc_receive_thread */
static int irq_read (void)
{
FILE *fh;
char buffer[1024];
fh = fopen ("/proc/interrupts", "r");
if (fh == NULL)
{
char errbuf[1024];
ERROR ("irq plugin: fopen (/proc/interrupts): %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, BUFSIZE, fh) != NULL)
{
char irq_name[64];
int irq_name_len;
derive_t irq_value;
char *endptr;
int i;
char *fields[64];
int fields_num;
fields_num = strsplit (buffer, fields, 64);
if (fields_num < 2)
continue;
errno = 0; /* To distinguish success/failure after call */
irq_name_len = ssnprintf (irq_name, sizeof (irq_name), "%s", fields[0]);
endptr = &irq_name[irq_name_len-1];
if ((endptr == fields[0]) || (errno != 0) || (*endptr != ':'))
continue;
/* remove : */
*endptr = 0;
irq_value = 0;
for (i = 1; i < fields_num; i++)
{
/* Per-CPU value */
value_t v;
int status;
status = irq_parse_value (fields[i], &v);
if (status != 0)
break;
irq_value += v.derive;
} /* for (i) */
irq_submit (irq_name, irq_value);
}
fclose (fh);
return (0);
} /* int irq_read */
size_t cdtime_to_iso8601 (char *s, size_t max, cdtime_t t) /* {{{ */
{
struct timespec t_spec;
struct tm t_tm;
size_t len;
CDTIME_T_TO_TIMESPEC (t, &t_spec);
NORMALIZE_TIMESPEC (t_spec);
if (localtime_r ((time_t *)&t_spec.tv_sec, &t_tm) == NULL) {
char errbuf[1024];
ERROR ("cdtime_to_iso8601: localtime_r failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (0);
}
len = strftime (s, max, "%Y-%m-%dT%H:%M:%S", &t_tm);
if (len == 0)
return 0;
if (max - len > 2) {
int n = snprintf (s + len, max - len, ".%09i", (int)t_spec.tv_nsec);
len += (n < max - len) ? n : max - len;
}
if (max - len > 3) {
int n = strftime (s + len, max - len, "%z", &t_tm);
len += (n < max - len) ? n : max - len;
}
s[max - 1] = '\0';
return len;
} /* }}} size_t cdtime_to_iso8601 */
static struct ip_vs_get_dests *ipvs_get_dests (struct ip_vs_service_entry *se)
{
struct ip_vs_get_dests *ret;
socklen_t len;
len = sizeof (*ret) + sizeof (struct ip_vs_dest_entry) * se->num_dests;
if (NULL == (ret = malloc (len))) {
log_err ("ipvs_get_dests: Out of memory.");
exit (3);
}
ret->fwmark = se->fwmark;
ret->protocol = se->protocol;
ret->addr = se->addr;
ret->port = se->port;
ret->num_dests = se->num_dests;
if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_DESTS,
(void *)ret, &len)) {
char errbuf[1024];
log_err ("ipvs_get_dests: getsockopt() failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
free (ret);
return NULL;
}
return ret;
} /* ip_vs_get_dests */
static int camqp_subscribe_init (camqp_config_t *conf) /* {{{ */
{
int status;
pthread_t *tmp;
tmp = realloc (subscriber_threads,
sizeof (*subscriber_threads) * (subscriber_threads_num + 1));
if (tmp == NULL)
{
ERROR ("amqp plugin: realloc failed.");
camqp_config_free (conf);
return (ENOMEM);
}
subscriber_threads = tmp;
tmp = subscriber_threads + subscriber_threads_num;
memset (tmp, 0, sizeof (*tmp));
status = pthread_create (tmp, /* attr = */ NULL,
camqp_subscribe_thread, conf);
if (status != 0)
{
char errbuf[1024];
ERROR ("amqp plugin: pthread_create failed: %s",
sstrerror (status, errbuf, sizeof (errbuf)));
camqp_config_free (conf);
return (status);
}
subscriber_threads_num++;
return (0);
} /* }}} int camqp_subscribe_init */
static void statsd_network_read (statsd_config_t *conf, int fd) /* {{{ */
{
char buffer[4096] = {0};
size_t buffer_size;
ssize_t status;
status = recv (fd, buffer, sizeof (buffer), /* flags = */ MSG_DONTWAIT);
if (status < 0)
{
char errbuf[1024];
if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
return;
ERROR ("statsd plugin: recv(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return;
}
buffer_size = (size_t) status;
if (buffer_size >= sizeof (buffer))
buffer_size = sizeof (buffer) - 1;
buffer[buffer_size] = 0;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
statsd_parse_buffer (conf, buffer);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
} /* }}} void statsd_network_read */
static int memcached_connect_unix (memcached_t *st)
{
struct sockaddr_un serv_addr;
int fd;
memset (&serv_addr, 0, sizeof (serv_addr));
serv_addr.sun_family = AF_UNIX;
sstrncpy (serv_addr.sun_path, st->socket,
sizeof (serv_addr.sun_path));
/* create our socket descriptor */
fd = socket (AF_UNIX, SOCK_STREAM, 0);
if (fd < 0)
{
char errbuf[1024];
ERROR ("memcached plugin: memcached_connect_unix: socket(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
/* connect to the memcached daemon */
int status = connect (fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
if (status != 0)
{
shutdown (fd, SHUT_RDWR);
close (fd);
fd = -1;
}
return (fd);
} /* int memcached_connect_unix */
static int numa_init (void) /* {{{ */
{
/* Determine the number of nodes on this machine. */
while (42)
{
char path[PATH_MAX];
struct stat statbuf = { 0 };
int status;
ssnprintf (path, sizeof (path), NUMA_ROOT_DIR "/node%i", max_node + 1);
status = stat (path, &statbuf);
if (status == 0)
{
max_node++;
continue;
}
else if (errno == ENOENT)
{
break;
}
else /* ((status != 0) && (errno != ENOENT)) */
{
char errbuf[1024];
ERROR ("numa plugin: stat(%s) failed: %s", path,
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
}
DEBUG ("numa plugin: Found %i nodes.", max_node + 1);
return (0);
} /* }}} int numa_init */
static int statsd_init (void) /* {{{ */
{
pthread_mutex_lock (&metrics_lock);
if (metrics_tree == NULL)
metrics_tree = c_avl_create ((void *) strcmp);
if (!network_thread_running)
{
int status;
status = pthread_create (&network_thread,
/* attr = */ NULL,
statsd_network_thread,
/* args = */ NULL);
if (status != 0)
{
char errbuf[1024];
pthread_mutex_unlock (&metrics_lock);
ERROR ("statsd plugin: pthread_create failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (status);
}
}
network_thread_running = 1;
pthread_mutex_unlock (&metrics_lock);
return (0);
} /* }}} int statsd_init */
static void statsd_network_read (int fd) /* {{{ */
{
char buffer[4096];
size_t buffer_size;
ssize_t status;
status = recv (fd, buffer, sizeof (buffer), /* flags = */ MSG_DONTWAIT);
if (status < 0)
{
char errbuf[1024];
if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
return;
ERROR ("statsd plugin: recv(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return;
}
buffer_size = (size_t) status;
if (buffer_size >= sizeof (buffer))
buffer_size = sizeof (buffer) - 1;
buffer[buffer_size] = 0;
statsd_parse_buffer (buffer);
} /* }}} void statsd_network_read */
static int
riemann_send(struct riemann_host *host, Msg const *msg)
{
u_char *buffer;
size_t buffer_len;
int status;
pthread_mutex_lock (&host->lock);
status = riemann_connect (host);
if (status != 0)
{
pthread_mutex_unlock (&host->lock);
return status;
}
buffer_len = msg__get_packed_size(msg);
if (host->use_tcp)
buffer_len += 4;
buffer = malloc (buffer_len);
if (buffer == NULL) {
pthread_mutex_unlock (&host->lock);
ERROR ("write_riemann plugin: malloc failed.");
return ENOMEM;
}
memset (buffer, 0, buffer_len);
if (host->use_tcp)
{
uint32_t length = htonl ((uint32_t) (buffer_len - 4));
memcpy (buffer, &length, 4);
msg__pack(msg, buffer + 4);
}
else
{
msg__pack(msg, buffer);
}
status = (int) swrite (host->s, buffer, buffer_len);
if (status != 0)
{
char errbuf[1024];
riemann_disconnect (host);
pthread_mutex_unlock (&host->lock);
ERROR ("write_riemann plugin: Sending to Riemann at %s:%s failed: %s",
(host->node != NULL) ? host->node : RIEMANN_HOST,
(host->service != NULL) ? host->service : RIEMANN_PORT,
sstrerror (errno, errbuf, sizeof (errbuf)));
sfree (buffer);
return -1;
}
pthread_mutex_unlock (&host->lock);
sfree (buffer);
return 0;
}
static int request_meta_data (const char *host, const char *name) /* {{{ */
{
Ganglia_metadata_msg msg;
char buffer[BUFF_SIZE];
unsigned int buffer_size;
XDR xdr;
size_t i;
memset (&msg, 0, sizeof (msg));
msg.id = gmetadata_request;
msg.Ganglia_metadata_msg_u.grequest.metric_id.host = strdup (host);
msg.Ganglia_metadata_msg_u.grequest.metric_id.name = strdup (name);
if ((msg.Ganglia_metadata_msg_u.grequest.metric_id.host == NULL)
|| (msg.Ganglia_metadata_msg_u.grequest.metric_id.name == NULL))
{
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
return (-1);
}
memset (buffer, 0, sizeof (buffer));
xdrmem_create (&xdr, buffer, sizeof (buffer), XDR_ENCODE);
if (!xdr_Ganglia_metadata_msg (&xdr, &msg))
{
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
return (-1);
}
buffer_size = xdr_getpos (&xdr);
DEBUG ("gmond plugin: Requesting meta data for %s/%s.",
host, name);
pthread_mutex_lock (&mc_send_sockets_lock);
for (i = 0; i < mc_send_sockets_num; i++)
{
ssize_t status = sendto (mc_send_sockets[i].fd, buffer, (size_t) buffer_size,
/* flags = */ 0,
(struct sockaddr *) &mc_send_sockets[i].addr,
mc_send_sockets[i].addrlen);
if (status == -1)
{
char errbuf[1024];
ERROR ("gmond plugin: sendto(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
continue;
}
}
pthread_mutex_unlock (&mc_send_sockets_lock);
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
return (0);
} /* }}} int request_meta_data */
static void *statsd_network_thread (void *args) /* {{{ */
{
statsd_config_t *conf = args;
fds_poll_t fds;
int status;
size_t i;
memset(&fds, 0, sizeof(fds_poll_t));
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
status = statsd_network_init (conf, &fds);
if (status != 0)
{
ERROR ("statsd plugin: Unable to open listening sockets.");
pthread_exit ((void *) 0);
}
pthread_cleanup_push(statsd_network_release, &fds);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
while (1) {
status = poll (fds.fds, (nfds_t) fds.fds_num, /* timeout = */ -1);
if (status < 0) {
char errbuf[1024] = {0};
if (EAGAIN == errno)
continue;
if (EINTR == errno) {
DEBUG("statsd plugin: poll(2) has been interrupted");
break;
}
ERROR ("statsd plugin: poll(2) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
break;
}
DEBUG("statsd plugin: ohh some moving in the sockets");
for (i = 0; i < fds.fds_num; i++) {
if ((fds.fds[i].revents & (POLLIN | POLLPRI)) == 0)
continue;
statsd_network_read(conf, fds.fds[i].fd);
fds.fds[i].revents = 0;
}
pthread_testcancel();
} /* wait for pthread_cancel */
pthread_cleanup_pop(1);
return ((void *) 0);
} /* }}} void *statsd_network_thread */
static int swap_read_separate (void) /* {{{ */
{
FILE *fh;
char buffer[1024];
fh = fopen ("/proc/swaps", "r");
if (fh == NULL)
{
char errbuf[1024];
WARNING ("swap plugin: fopen (/proc/swaps) failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, sizeof (buffer), fh) != NULL)
{
char *fields[8];
int numfields;
char *endptr;
char path[PATH_MAX];
gauge_t size;
gauge_t used;
gauge_t free;
numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
if (numfields != 5)
continue;
sstrncpy (path, fields[0], sizeof (path));
escape_slashes (path, sizeof (path));
errno = 0;
endptr = NULL;
size = strtod (fields[2], &endptr);
if ((endptr == fields[2]) || (errno != 0))
continue;
errno = 0;
endptr = NULL;
used = strtod (fields[3], &endptr);
if ((endptr == fields[3]) || (errno != 0))
continue;
if (size < used)
continue;
free = size - used;
swap_submit_gauge (path, "used", used);
swap_submit_gauge (path, "free", free);
}
fclose (fh);
return (0);
} /* }}} int swap_read_separate */
