Array static memcache_build_stats(const memcached_st *ptr,
memcached_stat_st *memc_stat,
memcached_return_t *ret) {
char **curr_key;
char **stat_keys = memcached_stat_get_keys(const_cast<memcached_st*>(ptr),
memc_stat, ret);
if (*ret != MEMCACHED_SUCCESS) {
if (stat_keys) {
free(stat_keys);
}
return NULL;
}
Array return_val = Array::Create();
for (curr_key = stat_keys; *curr_key; curr_key++) {
char *mc_val;
mc_val = memcached_stat_get_value(ptr, memc_stat, *curr_key, ret);
if (*ret != MEMCACHED_SUCCESS) {
break;
}
return_val.set(String(*curr_key, CopyString),
String(mc_val, CopyString));
free(mc_val);
}
free(stat_keys);
return return_val;
}
static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
memcached_server_st *server_list)
{
unsigned int x;
memcached_return rc;
printf("Listing %u Server\n\n", memcached_server_count(memc));
for (x= 0; x < memcached_server_count(memc); x++)
{
char **list;
char **ptr;
list= memcached_stat_get_keys(memc, &stat[x], &rc);
printf("Server: %s (%u)\n", memcached_server_name(memc, server_list[x]),
memcached_server_port(memc, server_list[x]));
for (ptr= list; *ptr; ptr++)
{
memcached_return rc;
char *value= memcached_stat_get_value(memc, &stat[x], *ptr, &rc);
printf("\t %s: %s\n", *ptr, value);
free(value);
}
free(list);
printf("\n");
}
}
/*doc Memcached stats
Returns a Map with servers' statistics. Keys are server addresses,
values are maps with actual stats.
*/
IoObject *IoMemcached_stats(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoMap *results_map = IoMap_new(IOSTATE);
int errors = 0;
uint32_t pos = 0;
while(pos < memcached_server_count(DATA(self)->mc)) {
memcached_server_instance_st server = memcached_server_instance_by_position(DATA(self)->mc, pos);
if(server == NULL)
continue;
const char *hostname = memcached_server_name(server);
const in_port_t port = memcached_server_port(server);
memcached_stat_st stats;
memcached_return_t rc = memcached_stat_servername(&stats, "", hostname, port);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
char **ckeys = memcached_stat_get_keys(DATA(self)->mc, &stats, &rc);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
IoMap *per_server_map = IoMap_new(IOSTATE);
char *ckey = *ckeys;
while(ckey != NULL) {
char *cvalue = memcached_stat_get_value(DATA(self)->mc, &stats, ckey, &rc);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
IoMap_rawAtPut(per_server_map, IOSYMBOL(ckey), IOSYMBOL(cvalue));
free(cvalue);
ckey++;
}
free(ckeys);
// "127.0.0.1:11211"
char *server_key = (char *) malloc((strlen(hostname) + 1 + 5 + 1) * sizeof(char));
sprintf(server_key, "%s:%d", hostname, port);
IoMap_rawAtPut(results_map, IOSYMBOL(server_key), per_server_map);
free(server_key);
pos++;
}
if(errors > 0)
IoState_error_(IOSTATE, m, memcached_strerror(DATA(self)->mc, MEMCACHED_SOME_ERRORS));
return results_map;
}
static int mcache_stat_servers(pr_memcache_t *mcache) {
memcached_stat_st *mst;
memcached_return res;
mst = memcached_stat(mcache->mc, NULL, &res);
if (mst != NULL) {
if (res == MEMCACHED_SUCCESS) {
register unsigned int i;
const char *stat_keys[] = {
"version",
"uptime",
"curr_connections",
"curr_items",
"bytes",
"limit_maxbytes",
NULL
};
/* Log some of the stats about the memcached servers to which we just
* connected.
*/
for (i = 0; stat_keys[i] != NULL; i++) {
char *info;
info = memcached_stat_get_value(mcache->mc, mst, stat_keys[i], &res);
if (info != NULL) {
pr_trace_msg(trace_channel, 9,
"memcached server stats: %s = %s", stat_keys[i], info);
free(info);
} else {
pr_trace_msg(trace_channel, 6,
"unable to obtain '%s' stat: %s", stat_keys[i],
memcached_strerror(mcache->mc, res));
}
}
} else {
switch (res) {
case MEMCACHED_ERRNO:
if (errno != EINPROGRESS) {
pr_trace_msg(trace_channel, 3,
"error requesting memcached stats: system error: %s",
strerror(errno));
} else {
/* We know that we're not using nonblocking IO; this value usually
* means that libmemcached could not connect to the configured
* memcached servers. So set the value to something more
* indicative, and fall through.
*/
res = MEMCACHED_CONNECTION_FAILURE;
}
break;
case MEMCACHED_SOME_ERRORS:
case MEMCACHED_SERVER_MARKED_DEAD:
case MEMCACHED_CONNECTION_FAILURE: {
memcached_server_instance_st server;
server = memcached_server_get_last_disconnect(mcache->mc);
if (server != NULL) {
pr_trace_msg(trace_channel, 3,
"unable to connect to %s:%d", memcached_server_name(server),
memcached_server_port(server));
}
break;
}
default:
pr_trace_msg(trace_channel, 6,
"error requesting memcached stats: %s",
memcached_strerror(mcache->mc, res));
break;
}
}
memcached_stat_free(mcache->mc, mst);
}
return 0;
}