git.m6w6.name Git - awesomized/libmemcached/blob - clients/memstat.c

   1 #include <stdio.h>
   2 #include <sys/types.h>
   3 #include <sys/stat.h>
   4 #include <sys/types.h>
   5 #include <sys/mman.h>
   6 #include <fcntl.h>
   7 #include <string.h>
   8 #include <getopt.h>
   9 #include <sys/time.h>
  10
  11 #include <libmemcached/memcached.h>
  12
  13 #include "client_options.h"
  14 #include "utilities.h"
  15
  16 #define PROGRAM_NAME "memstat"
  17 #define PROGRAM_DESCRIPTION "Output the state of a memcached cluster."
  18
  19 /* Prototypes */
  20 static void options_parse(int argc, char *argv[]);
  21 static void run_analyzer(memcached_st *memc, memcached_stat_st *stat,
  22                          memcached_server_st *server_list);
  23 static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
  24                                  memcached_server_st *server_list);
  25 static void print_analysis_report(memcached_st *memc,
  26                                   memcached_analysis_st *report,
  27                                   memcached_server_st *server_list);
  28
  29 static int opt_verbose= 0;
  30 static int opt_displayflag= 0;
  31 static int opt_analyze= 0;
  32 static char *opt_servers= NULL;
  33 static char *analyze_mode= NULL;
  34
  35 static struct option long_options[]=
  36 {
  37   {"version", no_argument, NULL, OPT_VERSION},
  38   {"help", no_argument, NULL, OPT_HELP},
  39   {"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
  40   {"debug", no_argument, &opt_verbose, OPT_DEBUG},
  41   {"servers", required_argument, NULL, OPT_SERVERS},
  42   {"flag", no_argument, &opt_displayflag, OPT_FLAG},
  43   {"analyze", optional_argument, NULL, OPT_ANALYZE},
  44   {0, 0, 0, 0},
  45 };
  46
  47 int main(int argc, char *argv[])
  48 {
  49   memcached_return rc;
  50   memcached_st *memc;
  51   memcached_stat_st *stat;
  52   memcached_server_st *servers;
  53   memcached_server_st *server_list;
  54
  55   options_parse(argc, argv);
  56
  57   if (!opt_servers)
  58   {
  59     char *temp;
  60
  61     if ((temp= getenv("MEMCACHED_SERVERS")))
  62       opt_servers= strdup(temp);
  63     else
  64     {
  65       fprintf(stderr, "No Servers provided\n\n");
  66       help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, 0);
  67       exit(1);
  68     }
  69   }
  70
  71   memc= memcached_create(NULL);
  72
  73   servers= memcached_servers_parse(opt_servers);
  74   memcached_server_push(memc, servers);
  75   memcached_server_list_free(servers);
  76
  77   stat= memcached_stat(memc, NULL, &rc);
  78
  79   if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS)
  80   {
  81     printf("Failure to communicate with servers (%s)\n",
  82            memcached_strerror(memc, rc));
  83     exit(1);
  84   }
  85
  86   server_list= memcached_server_list(memc);
  87
  88   if (opt_analyze)
  89     run_analyzer(memc, stat, server_list);
  90   else
  91     print_server_listing(memc, stat, server_list);
  92
  93   free(stat);
  94   free(opt_servers);
  95
  96   memcached_free(memc);
  97
  98   return 0;
  99 }
 100
 101 static void run_analyzer(memcached_st *memc, memcached_stat_st *stat,
 102                          memcached_server_st *server_list)
 103 {
 104   memcached_return rc;
 105
 106   if (analyze_mode == NULL)
 107   {
 108     memcached_analysis_st *report;
 109     report= memcached_analyze(memc, stat, &rc);
 110     if (rc != MEMCACHED_SUCCESS || report == NULL)
 111     {
 112       printf("Failure to analyze servers (%s)\n",
 113              memcached_strerror(memc, rc));
 114       exit(1);
 115     }
 116     print_analysis_report(memc, report, server_list);
 117     free(report);
 118   }
 119   else if (strcmp(analyze_mode, "latency") == 0)
 120   {
 121     memcached_st **servers;
 122     uint32_t x, y, flags, server_count= memcached_server_count(memc);
 123     uint32_t num_of_tests= 32;
 124     const char *test_key= "libmemcached_test_key";
 125
 126     servers= malloc(sizeof(memcached_st*) * server_count);
 127     if (!servers)
 128     {
 129       fprintf(stderr, "Failed to allocate memory\n");
 130       return;
 131     }
 132
 133     for (x= 0; x < server_count; x++)
 134     {
 135       if((servers[x]= memcached_create(NULL)) == NULL)
 136       {
 137         fprintf(stderr, "Failed to memcached_create()\n");
 138         x--;
 139         for (; x >= 0; x--)
 140           memcached_free(servers[x]);
 141         free(servers);
 142         return;
 143       }
 144       memcached_server_add(servers[x],
 145                            memcached_server_name(memc, server_list[x]),
 146                            memcached_server_port(memc, server_list[x]));
 147     }
 148
 149     printf("Network Latency Test:\n\n");
 150     struct timeval start_time, end_time;
 151     long elapsed_time, slowest_time= 0, slowest_server= 0;
 152
 153     for (x= 0; x < server_count; x++)
 154     {
 155       gettimeofday(&start_time, NULL);
 156       for (y= 0; y < num_of_tests; y++)
 157       {
 158         size_t vlen;
 159         char *val= memcached_get(servers[x], test_key, strlen(test_key),
 160                                  &vlen, &flags, &rc);
 161         if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
 162           break;
 163         free(val);
 164       }
 165       gettimeofday(&end_time, NULL);
 166
 167       elapsed_time= timedif(end_time, start_time);
 168       elapsed_time /= num_of_tests;
 169
 170       if (elapsed_time > slowest_time)
 171       {
 172         slowest_server= x;
 173         slowest_time= elapsed_time;
 174       }
 175
 176       if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
 177       {
 178         printf("\t %s (%d)  =>  failed to reach the server\n",
 179                memcached_server_name(memc, server_list[x]),
 180                memcached_server_port(memc, server_list[x]));
 181       }
 182       else
 183       {
 184         printf("\t %s (%d)  =>  %ld.%ld seconds\n",
 185                memcached_server_name(memc, server_list[x]),
 186                memcached_server_port(memc, server_list[x]),
 187                elapsed_time / 1000, elapsed_time % 1000);
 188       }
 189     }
 190
 191     if (server_count > 1 && slowest_time > 0)
 192     {
 193       printf("---\n");
 194       printf("Slowest Server: %s (%d) => %ld.%ld seconds\n",
 195              memcached_server_name(memc, server_list[slowest_server]),
 196              memcached_server_port(memc, server_list[slowest_server]),
 197              slowest_time / 1000, slowest_time % 1000);
 198     }
 199     printf("\n");
 200
 201     for (x= 0; x < server_count; x++)
 202       memcached_free(servers[x]);
 203
 204     free(servers);
 205     free(analyze_mode);
 206   }
 207   else
 208   {
 209     fprintf(stderr, "Invalid Analyzer Option provided\n");
 210     free(analyze_mode);
 211   }
 212 }
 213
 214 static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
 215                                  memcached_server_st *server_list)
 216 {
 217   unsigned int x;
 218   memcached_return rc;
 219
 220   printf("Listing %u Server\n\n", memcached_server_count(memc));
 221   for (x= 0; x < memcached_server_count(memc); x++)
 222   {
 223     char **list;
 224     char **ptr;
 225
 226     list= memcached_stat_get_keys(memc, &stat[x], &rc);
 227
 228     printf("Server: %s (%u)\n", memcached_server_name(memc, server_list[x]),
 229            memcached_server_port(memc, server_list[x]));
 230     for (ptr= list; *ptr; ptr++)
 231     {
 232       memcached_return rc;
 233       char *value= memcached_stat_get_value(memc, &stat[x], *ptr, &rc);
 234
 235       printf("\t %s: %s\n", *ptr, value);
 236       free(value);
 237     }
 238
 239     free(list);
 240     printf("\n");
 241   }
 242 }
 243
 244 static void print_analysis_report(memcached_st *memc,
 245                                   memcached_analysis_st *report,
 246                                   memcached_server_st *server_list)
 247 {
 248   uint32_t server_count= memcached_server_count(memc);
 249
 250   printf("Memcached Cluster Analysis Report\n\n");
 251
 252   printf("\tNumber of Servers Analyzed         : %d\n", server_count);
 253   printf("\tAverage Item Size (incl/overhead)  : %u bytes\n",
 254          report->average_item_size);
 255
 256   if (server_count == 1)
 257   {
 258     printf("\nFor a detailed report, you must supply multiple servers.\n");
 259     return;
 260   }
 261
 262   printf("\n");
 263   printf("\tNode with most memory consumption  : %s:%u (%llu bytes)\n",
 264          memcached_server_name(memc, server_list[report->most_consumed_server]),
 265          memcached_server_port(memc, server_list[report->most_consumed_server]),
 266          (unsigned long long)report->most_used_bytes);
 267   printf("\tNode with least free space         : %s:%u (%llu bytes remaining)\n",
 268          memcached_server_name(memc, server_list[report->least_free_server]),
 269          memcached_server_port(memc, server_list[report->least_free_server]),
 270          (unsigned long long)report->least_remaining_bytes);
 271   printf("\tNode with longest uptime           : %s:%u (%us)\n",
 272          memcached_server_name(memc, server_list[report->oldest_server]),
 273          memcached_server_port(memc, server_list[report->oldest_server]),
 274          report->longest_uptime);
 275   printf("\tPool-wide Hit Ratio                : %1.f%%\n", report->pool_hit_ratio);
 276   printf("\n");
 277 }
 278
 279 static void options_parse(int argc, char *argv[])
 280 {
 281   memcached_programs_help_st help_options[]=
 282   {
 283     {0},
 284   };
 285
 286   int option_index= 0;
 287   int option_rv;
 288
 289   while (1)
 290   {
 291     option_rv= getopt_long(argc, argv, "Vhvds:a", long_options, &option_index);
 292     if (option_rv == -1) break;
 293     switch (option_rv)
 294     {
 295     case 0:
 296       break;
 297     case OPT_VERBOSE: /* --verbose or -v */
 298       opt_verbose = OPT_VERBOSE;
 299       break;
 300     case OPT_DEBUG: /* --debug or -d */
 301       opt_verbose = OPT_DEBUG;
 302       break;
 303     case OPT_VERSION: /* --version or -V */
 304       version_command(PROGRAM_NAME);
 305       break;
 306     case OPT_HELP: /* --help or -h */
 307       help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
 308       break;
 309     case OPT_SERVERS: /* --servers or -s */
 310       opt_servers= strdup(optarg);
 311       break;
 312     case OPT_ANALYZE: /* --analyze or -a */
 313       opt_analyze= OPT_ANALYZE;
 314       analyze_mode= (optarg) ? strdup(optarg) : NULL;
 315       break;
 316     case '?':
 317       /* getopt_long already printed an error message. */
 318       exit(1);
 319     default:
 320       abort();
 321     }
 322   }
 323 }