static test_return_t udp_stat_test(memcached_st *memc)
{
memcached_stat_st * rv= NULL;
memcached_return_t rc;
char args[]= "";
uint16_t *expected_ids = get_udp_request_ids(memc);
rv = memcached_stat(memc, args, &rc);
free(rv);
test_true(rc == MEMCACHED_NOT_SUPPORTED);
return post_udp_op_check(memc, expected_ids);
}
static int cdb_count(knot_db_t *db)
{
struct memcached_cli *cli = db;
memcached_return_t error = 0;
memcached_stat_st *stats = memcached_stat(cli->handle, NULL, &error);
if (error != 0) {
return kr_error(EIO);
}
size_t ret = stats->curr_items;
free(stats);
return (ret > INT_MAX) ? INT_MAX : ret;
}
static void lmd_postparse_ev(const void *event_data, void *user_data) {
memcached_stat_st *unused;
memcached_return rc;
unused = memcached_stat(memcached_deny_blacklist_mmc, NULL, &rc);
if(rc != MEMCACHED_SUCCESS) {
pr_log_pri(PR_LOG_WARNING,
"%s: Failed connect to memcached."
"Please check memcached is alive", MODULE_NAME);
if(ignore_memcached_down){
return;
}else {
exit(1);
}
}
}
Array c_Memcache::t_getextendedstats(const String& type /* = null_string */,
int slabid /* = 0 */,
int limit /* = 100 */) {
memcached_return_t ret;
memcached_stat_st *stats;
stats = memcached_stat(&m_memcache, NULL, &ret);
if (ret != MEMCACHED_SUCCESS) {
return NULL;
}
int server_count = memcached_server_count(&m_memcache);
Array return_val;
for (int server_id = 0; server_id < server_count; server_id++) {
memcached_stat_st *stat;
char stats_key[30] = {0};
size_t key_len;
LMCD_SERVER_POSITION_INSTANCE_TYPE instance =
memcached_server_instance_by_position(&m_memcache, server_id);
const char *hostname = LMCD_SERVER_HOSTNAME(instance);
in_port_t port = LMCD_SERVER_PORT(instance);
stat = stats + server_id;
Array server_stats = memcache_build_stats(&m_memcache, stat, &ret);
if (ret != MEMCACHED_SUCCESS) {
continue;
}
key_len = snprintf(stats_key, sizeof(stats_key), "%s:%d", hostname, port);
return_val.set(String(stats_key, key_len, CopyString), server_stats);
}
free(stats);
return return_val;
}
Array c_Memcache::t_getextendedstats(CStrRef type /* = null_string */,
int slabid /* = 0 */,
int limit /* = 100 */) {
memcached_return_t ret;
memcached_stat_st *stats;
stats = memcached_stat(&m_memcache, NULL, &ret);
if (ret != MEMCACHED_SUCCESS) {
return NULL;
}
int server_count = memcached_server_count(&m_memcache);
Array return_val;
for (int server_id = 0; server_id < server_count; server_id++) {
memcached_server_instance_st server;
memcached_stat_st *stat;
char stats_key[30] = {0};
size_t key_len;
server = memcached_server_instance_by_position(&m_memcache, server_id);
stat = stats + server_id;
Array server_stats = memcache_build_stats(&m_memcache, stat, &ret);
if (ret != MEMCACHED_SUCCESS) {
continue;
}
key_len = snprintf(stats_key, sizeof(stats_key),
"%s:%d", server->hostname, server->port);
return_val.set(String(stats_key, key_len, CopyString), server_stats);
}
free(stats);
return return_val;
}
bool ESPMemCached::checkServersUp()
{
memcached_return_t rc;
char* args = nullptr;
OwnedMalloc<memcached_stat_st> stats;
stats.setown(memcached_stat(connection, args, &rc));
unsigned int numberOfServers = memcached_server_count(connection);
if (numberOfServers < 1)
{
ESPLOG(LogMin,"ESPMemCached: no server connected.");
return false;
}
unsigned int numberOfServersDown = 0;
for (unsigned i = 0; i < numberOfServers; ++i)
{
if (stats[i].pid == -1)//perhaps not the best test?
{
numberOfServersDown++;
VStringBuffer msg("ESPMemCached: Failed connecting to entry %u\nwithin the server list: %s", i+1, options.str());
ESPLOG(LogMin, "%s", msg.str());
}
}
if (numberOfServersDown == numberOfServers)
{
ESPLOG(LogMin,"ESPMemCached: Failed connecting to ALL servers. Check memcached on all servers and \"memcached -B ascii\" not used.");
return false;
}
//check memcached version homogeneity
for (unsigned i = 0; i < numberOfServers-1; ++i)
{
if (!streq(stats[i].version, stats[i+1].version))
DBGLOG("ESPMemCached: Inhomogeneous versions of memcached across servers.");
}
return true;
}
int main(int argc, char *argv[])
{
memcached_return rc;
memcached_st *memc;
memcached_stat_st *stat;
memcached_server_st *servers;
memcached_server_st *server_list;
memcached_analysis_st *report;
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n\n");
help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, 0);
exit(1);
}
}
memc= memcached_create(NULL);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
stat= memcached_stat(memc, NULL, &rc);
if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS)
{
printf("Failure to communicate with servers (%s)\n",
memcached_strerror(memc, rc));
exit(1);
}
server_list= memcached_server_list(memc);
if (opt_analyze)
{
report= memcached_analyze(memc, stat, &rc);
if (rc != MEMCACHED_SUCCESS || report == NULL)
{
printf("Failure to analyze servers (%s)\n",
memcached_strerror(memc, rc));
exit(1);
}
print_analysis_report(memc, report, server_list);
free(report);
}
else
print_server_listing(memc, stat, server_list);
free(stat);
free(opt_servers);
memcached_free(memc);
return 0;
}
unsigned int x;
memcached_return rc;
char buf[100];
memcached_stat_st *stat;
memcached_server_st *servers;
memcached_server_st *server_list;
memc_function_st *container= (memc_function_st *)initid->ptr;
memcached_string_reset(container->stats_string);
servers= memcached_servers_parse(args->args[0]);
memcached_server_push(&container->memc, servers);
memcached_server_list_free(servers);
stat= memcached_stat(&container->memc, NULL, &rc);
if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS)
{
sprintf(error, "Failure to communicate with servers (%s)\n",
memcached_strerror(&container->memc, rc));
*length= strlen(error);
return(error);
}
server_list= memcached_server_list(&container->memc);
sprintf(buf, "Listing %u Server\n\n", memcached_server_count(&container->memc));
memcached_string_append(container->stats_string, buf, strlen(buf));
for (x= 0; x < memcached_server_count(&container->memc); x++)
{
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;
}
int main(int argc, char ** argv)
{
struct memcached_st *mc;
struct memcached_stat_st *stats;
memcached_return_t rc;
long cur_conn = -1;
int status;
char* status_msg;
struct timeval tv;
long microsec;
double elapsed_time;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv = np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
TRACE("%s",">>main");
// initialize
gettimeofday(&tv, NULL);
mc = memcached_create(NULL);
if (mc == NULL) {
printf("MEMCACHED %s: failed to memcached_create\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
TRACE("[server]%s:%s", mc_host, mc_port);
rc = memcached_server_add(mc, mc_host, (in_port_t)mc_port);
TRACE("[mc_server_add rv]%d", rc);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to memcached_server_add (%d)\n", _("CRITICAL"), rc);
exit(EXIT_CRITICAL);
}
memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
stats = memcached_stat(mc, NULL, &rc);
if (! stats) {
printf("MEMCACHED %s: failed to memcached_stats\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
cur_conn = stats->curr_connections;
memcached_stat_free(mc, stats);
memcached_free(mc);
status = get_status(cur_conn, my_thresholds);
status_msg = _("CRITICAL");
if (status == STATE_OK) {
status_msg = _("OK");
} else if (status == STATE_WARNING) {
status_msg = _("WARNING");
} else if (status == STATE_CRITICAL) {
status_msg = _("CRITICAL");
}
microsec = deltime(tv);
elapsed_time = (double)microsec / 1.0e6;
printf("MEMCACHED %s: conn %ld, %.3f seconds\n", status_msg, cur_conn, elapsed_time);
return status;
}
