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 */
fd = -1;
}
- return (fd);
+ return fd;
} /* int memcached_connect_unix */
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;
}
freeaddrinfo(ai_list);
- return (fd);
+ return fd;
} /* int memcached_connect_inet */
static int memcached_connect(memcached_t *st) {
if (st->socket != NULL)
- return (memcached_connect_unix(st));
+ return memcached_connect_unix(st);
else
- return (memcached_connect_inet(st));
+ return memcached_connect_inet(st);
}
static int memcached_query_daemon(char *buffer, size_t buffer_size,
sstrerror(errno, errbuf, sizeof(errbuf)));
shutdown(fd, SHUT_RDWR);
close(fd);
- return (-1);
+ return -1;
}
/* receive data from the memcached daemon */
sstrerror(errno, errbuf, sizeof(errbuf)));
shutdown(fd, SHUT_RDWR);
close(fd);
- return (-1);
+ return -1;
}
buffer_fill += (size_t)status;
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) {
}
/*
- * 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);
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);
}
/*
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 <Address> used then:
* - Connect to the destination specified by <Host>, if present.
* If not, use the default address.
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))
} 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
st = calloc(1, sizeof(*st));
if (st == NULL) {
ERROR("memcached plugin: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
st->name = NULL;
if (status != 0) {
sfree(st);
- return (status);
+ return status;
}
for (int i = 0; i < ci->children_num; i++) {
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++) {
} else if (!have_instance_block) {
/* Non-instance option: Assume legacy configuration (without <Instance />
* blocks) and call config_add_instance() with the <Plugin /> 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 "
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;
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) {