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; }