X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fmemcached.c;h=1eb02a3c649c8b956dcdebe4865be8b1cc9ecb4a;hb=686bd66e6b1624c07f8c469b41e902d5bfc33131;hp=79c38a798ec99e99203e0fa422534fd4fbd94023;hpb=11c8a760c2d354b2f4637bdb297efb253bfaa519;p=collectd.git diff --git a/src/memcached.c b/src/memcached.c index 79c38a79..1eb02a3c 100644 --- a/src/memcached.c +++ b/src/memcached.c @@ -5,6 +5,7 @@ * Copyright (C) 2009 Doug MacEachern * Copyright (C) 2009 Franck Lombardi * Copyright (C) 2012 Nicolas Szalay + * Copyright (C) 2017 Pavel Rochnyak * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -26,6 +27,7 @@ * Doug MacEachern * Franck Lombardi * Nicolas Szalay + * Pavel Rochnyak **/ #include "collectd.h" @@ -38,8 +40,12 @@ #include #include +#include + #define MEMCACHED_DEF_HOST "127.0.0.1" #define MEMCACHED_DEF_PORT "11211" +#define MEMCACHED_CONNECT_TIMEOUT 10000 +#define MEMCACHED_IO_TIMEOUT 5000 struct memcached_s { char *name; @@ -47,6 +53,7 @@ struct memcached_s { char *socket; char *connhost; char *connport; + int fd; }; typedef struct memcached_s memcached_t; @@ -57,6 +64,12 @@ static void memcached_free(void *arg) { if (st == NULL) return; + if (st->fd >= 0) { + shutdown(st->fd, SHUT_RDWR); + close(st->fd); + st->fd = -1; + } + sfree(st->name); sfree(st->host); sfree(st->socket); @@ -78,7 +91,7 @@ static int memcached_connect_unix(memcached_t *st) { char errbuf[1024]; ERROR("memcached plugin: memcached_connect_unix: socket(2) failed: %s", sstrerror(errno, errbuf, sizeof(errbuf))); - return (-1); + return -1; } /* connect to the memcached daemon */ @@ -86,10 +99,18 @@ static int memcached_connect_unix(memcached_t *st) { if (status != 0) { shutdown(fd, SHUT_RDWR); close(fd); - fd = -1; + return -1; } - return (fd); + /* switch to non-blocking mode */ + int flags = fcntl(fd, F_GETFL); + status = fcntl(fd, F_SETFL, flags | O_NONBLOCK); + if (status != 0) { + close(fd); + return -1; + } + + return fd; } /* int memcached_connect_unix */ static int memcached_connect_inet(memcached_t *st) { @@ -109,7 +130,7 @@ static int memcached_connect_inet(memcached_t *st) { st->connhost, st->connport, (status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf)) : gai_strerror(status)); - return (-1); + return -1; } for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; @@ -124,77 +145,152 @@ static int memcached_connect_inet(memcached_t *st) { continue; } + /* switch socket to non-blocking mode */ + int flags = fcntl(fd, F_GETFL); + status = fcntl(fd, F_SETFL, flags | O_NONBLOCK); + if (status != 0) { + close(fd); + fd = -1; + continue; + } + /* connect to the memcached daemon */ status = (int)connect(fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen); - if (status != 0) { + if (status != 0 && errno != EINPROGRESS) { shutdown(fd, SHUT_RDWR); close(fd); fd = -1; continue; } - /* A socket could be opened and connecting succeeded. We're done. */ + /* Wait until connection establishes */ + struct pollfd pollfd = { + .fd = fd, .events = POLLOUT, + }; + do + status = poll(&pollfd, 1, MEMCACHED_CONNECT_TIMEOUT); + while (status < 0 && errno == EINTR); + if (status <= 0) { + close(fd); + fd = -1; + continue; + } + + /* Check if all is good */ + int socket_error; + status = getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&socket_error, + &(socklen_t){sizeof(socket_error)}); + if (status != 0 || socket_error != 0) { + close(fd); + fd = -1; + continue; + } + /* A socket is opened and connection succeeded. We're done. */ break; } freeaddrinfo(ai_list); - return (fd); + return fd; } /* int memcached_connect_inet */ -static int memcached_connect(memcached_t *st) { +static void memcached_connect(memcached_t *st) { + if (st->fd >= 0) + return; + if (st->socket != NULL) - return (memcached_connect_unix(st)); + st->fd = memcached_connect_unix(st); else - return (memcached_connect_inet(st)); + st->fd = memcached_connect_inet(st); + + if (st->fd >= 0) + INFO("memcached plugin: Instance \"%s\": connection established.", + st->name); } static int memcached_query_daemon(char *buffer, size_t buffer_size, memcached_t *st) { - int fd, status; + int status; size_t buffer_fill; - fd = memcached_connect(st); - if (fd < 0) { + memcached_connect(st); + if (st->fd < 0) { ERROR("memcached plugin: Instance \"%s\" could not connect to daemon.", st->name); return -1; } - status = (int)swrite(fd, "stats\r\n", strlen("stats\r\n")); + struct pollfd pollfd = { + .fd = st->fd, .events = POLLOUT, + }; + + do + status = poll(&pollfd, 1, MEMCACHED_IO_TIMEOUT); + while (status < 0 && errno == EINTR); + + if (status <= 0) { + ERROR("memcached plugin: poll() failed for write() call."); + close(st->fd); + st->fd = -1; + return -1; + } + + status = (int)swrite(st->fd, "stats\r\n", strlen("stats\r\n")); if (status != 0) { char errbuf[1024]; - ERROR("memcached plugin: write(2) failed: %s", + ERROR("memcached plugin: Instance \"%s\": write(2) failed: %s", st->name, sstrerror(errno, errbuf, sizeof(errbuf))); - shutdown(fd, SHUT_RDWR); - close(fd); - return (-1); + shutdown(st->fd, SHUT_RDWR); + close(st->fd); + st->fd = -1; + return -1; } /* receive data from the memcached daemon */ memset(buffer, 0, buffer_size); buffer_fill = 0; - while ((status = (int)recv(fd, buffer + buffer_fill, - buffer_size - buffer_fill, /* flags = */ 0)) != - 0) { + pollfd.events = POLLIN; + while (1) { + do + status = poll(&pollfd, 1, MEMCACHED_IO_TIMEOUT); + while (status < 0 && errno == EINTR); + + if (status <= 0) { + ERROR("memcached plugin: Instance \"%s\": Timeout reading from socket", + st->name); + close(st->fd); + st->fd = -1; + return -1; + } + + do + status = (int)recv(st->fd, buffer + buffer_fill, + buffer_size - buffer_fill, /* flags = */ 0); + while (status < 0 && errno == EINTR); + char const end_token[5] = {'E', 'N', 'D', '\r', '\n'}; if (status < 0) { char errbuf[1024]; - if ((errno == EAGAIN) || (errno == EINTR)) + if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) continue; - ERROR("memcached: Error reading from socket: %s", - sstrerror(errno, errbuf, sizeof(errbuf))); - shutdown(fd, SHUT_RDWR); - close(fd); - return (-1); + ERROR("memcached plugin: Instance \"%s\": Error reading from socket: %s", + st->name, sstrerror(errno, errbuf, sizeof(errbuf))); + shutdown(st->fd, SHUT_RDWR); + close(st->fd); + st->fd = -1; + return -1; } buffer_fill += (size_t)status; if (buffer_fill > buffer_size) { buffer_fill = buffer_size; - WARNING("memcached plugin: Message was truncated."); + WARNING("memcached plugin: Instance \"%s\": Message was truncated.", + st->name); + shutdown(st->fd, SHUT_RDWR); + close(st->fd); + st->fd = -1; break; } @@ -206,13 +302,12 @@ static int memcached_query_daemon(char *buffer, size_t buffer_size, status = 0; if (buffer_fill == 0) { - WARNING("memcached plugin: No data returned by memcached."); + WARNING("memcached plugin: Instance \"%s\": No data returned by memcached.", + st->name); status = -1; } - shutdown(fd, SHUT_RDWR); - close(fd); - return (status); + return status; } /* int memcached_query_daemon */ static void memcached_init_vl(value_list_t *vl, memcached_t const *st) { @@ -412,8 +507,10 @@ static int memcached_read(user_data_t *user_data) { } /* - * Operations on the cache, i. e. cache hits, cache misses and evictions of - * items + * Operations on the cache: + * - get hits/misses + * - delete hits/misses + * - evictions */ else if (FIELD_IS("get_hits")) { submit_derive("memcached_ops", "hits", atoll(fields[2]), st); @@ -422,6 +519,10 @@ static int memcached_read(user_data_t *user_data) { submit_derive("memcached_ops", "misses", atoll(fields[2]), st); } else if (FIELD_IS("evictions")) { submit_derive("memcached_ops", "evictions", atoll(fields[2]), st); + } else if (FIELD_IS("delete_hits")) { + submit_derive("memcached_ops", "delete_hits", atoll(fields[2]), st); + } else if (FIELD_IS("delete_misses")) { + submit_derive("memcached_ops", "delete_misses", atoll(fields[2]), st); } /* @@ -467,13 +568,7 @@ static int memcached_read(user_data_t *user_data) { return 0; } /* int memcached_read */ -static int memcached_add_read_callback(memcached_t *st) { - char callback_name[3 * DATA_MAX_NAME_LEN]; - int status; - - ssnprintf(callback_name, sizeof(callback_name), "memcached/%s", - (st->name != NULL) ? st->name : "__legacy__"); - +static int memcached_set_defaults(memcached_t *st) { /* If no
used then: * - Connect to the destination specified by , if present. * If not, use the default address. @@ -489,7 +584,7 @@ static int memcached_add_read_callback(memcached_t *st) { if (st->host) { st->connhost = strdup(st->host); if (st->connhost == NULL) - return (ENOMEM); + return ENOMEM; if ((strcmp("127.0.0.1", st->host) == 0) || (strcmp("localhost", st->host) == 0)) @@ -497,28 +592,41 @@ static int memcached_add_read_callback(memcached_t *st) { } else { st->connhost = strdup(MEMCACHED_DEF_HOST); if (st->connhost == NULL) - return (ENOMEM); + return ENOMEM; } } if (st->connport == NULL) { st->connport = strdup(MEMCACHED_DEF_PORT); if (st->connport == NULL) - return (ENOMEM); + return ENOMEM; } assert(st->connhost != NULL); assert(st->connport != NULL); - status = plugin_register_complex_read( + return 0; +} /* int memcached_set_defaults */ + +static int memcached_add_read_callback(memcached_t *st) { + char callback_name[3 * DATA_MAX_NAME_LEN]; + + if (memcached_set_defaults(st) != 0) { + memcached_free(st); + return -1; + } + + snprintf(callback_name, sizeof(callback_name), "memcached/%s", + (st->name != NULL) ? st->name : "__legacy__"); + + return plugin_register_complex_read( /* group = */ "memcached", /* name = */ callback_name, /* callback = */ memcached_read, - /* interval = */ 0, &(user_data_t){ - .data = st, .free_func = memcached_free, - }); - - return (status); + /* interval = */ 0, + &(user_data_t){ + .data = st, .free_func = memcached_free, + }); } /* int memcached_add_read_callback */ /* Configuration handling functiions @@ -540,7 +648,7 @@ static int config_add_instance(oconfig_item_t *ci) { st = calloc(1, sizeof(*st)); if (st == NULL) { ERROR("memcached plugin: calloc failed."); - return (ENOMEM); + return ENOMEM; } st->name = NULL; @@ -549,12 +657,14 @@ static int config_add_instance(oconfig_item_t *ci) { st->connhost = NULL; st->connport = NULL; + st->fd = -1; + if (strcasecmp(ci->key, "Instance") == 0) status = cf_util_get_string(ci, &st->name); if (status != 0) { sfree(st); - return (status); + return status; } for (int i = 0; i < ci->children_num; i++) { @@ -577,19 +687,15 @@ static int config_add_instance(oconfig_item_t *ci) { break; } - if (status == 0) - status = memcached_add_read_callback(st); - if (status != 0) { memcached_free(st); - return (-1); + return -1; } - return (0); -} + return memcached_add_read_callback(st); +} /* int config_add_instance */ static int memcached_config(oconfig_item_t *ci) { - int status = 0; _Bool have_instance_block = 0; for (int i = 0; i < ci->children_num; i++) { @@ -601,7 +707,7 @@ static int memcached_config(oconfig_item_t *ci) { } else if (!have_instance_block) { /* Non-instance option: Assume legacy configuration (without * blocks) and call config_add_instance() with the block. */ - return (config_add_instance(ci)); + return config_add_instance(ci); } else WARNING("memcached plugin: The configuration option " "\"%s\" is not allowed here. Did you " @@ -610,33 +716,33 @@ static int memcached_config(oconfig_item_t *ci) { child->key); } /* for (ci->children) */ - return (status); -} + return 0; +} /* int memcached_config */ static int memcached_init(void) { memcached_t *st; int status; if (memcached_have_instances) - return (0); + return 0; /* No instances were configured, lets start a default instance. */ st = calloc(1, sizeof(*st)); if (st == NULL) - return (ENOMEM); + return ENOMEM; st->name = NULL; st->host = NULL; st->socket = NULL; st->connhost = NULL; st->connport = NULL; + st->fd = -1; + status = memcached_add_read_callback(st); if (status == 0) memcached_have_instances = 1; - else - memcached_free(st); - return (status); + return status; } /* int memcached_init */ void module_register(void) {