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         if (x > 0)
 139           memcached_free(servers[0]);
 140         x--;
 141         for (; x > 0; x--)
 142           memcached_free(servers[x]);
 143
 144         free(servers);
 145         return;
 146       }
 147       memcached_server_add(servers[x],
 148                            memcached_server_name(memc, server_list[x]),
 149                            memcached_server_port(memc, server_list[x]));
 150     }
 151
 152     printf("Network Latency Test:\n\n");
 153     struct timeval start_time, end_time;
 154     long elapsed_time, slowest_time= 0, slowest_server= 0;
 155
 156     for (x= 0; x < server_count; x++)
 157     {
 158       gettimeofday(&start_time, NULL);
 159       for (y= 0; y < num_of_tests; y++)
 160       {
 161         size_t vlen;
 162         char *val= memcached_get(servers[x], test_key, strlen(test_key),
 163                                  &vlen, &flags, &rc);
 164         if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
 165           break;
 166         free(val);
 167       }
 168       gettimeofday(&end_time, NULL);
 169
 170       elapsed_time= timedif(end_time, start_time);
 171       elapsed_time /= num_of_tests;
 172
 173       if (elapsed_time > slowest_time)
 174       {
 175         slowest_server= x;
 176         slowest_time= elapsed_time;
 177       }
 178
 179       if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
 180       {
 181         printf("\t %s (%d)  =>  failed to reach the server\n",
 182                memcached_server_name(memc, server_list[x]),
 183                memcached_server_port(memc, server_list[x]));
 184       }
 185       else
 186       {
 187         printf("\t %s (%d)  =>  %ld.%ld seconds\n",
 188                memcached_server_name(memc, server_list[x]),
 189                memcached_server_port(memc, server_list[x]),
 190                elapsed_time / 1000, elapsed_time % 1000);
 191       }
 192     }
 193
 194     if (server_count > 1 && slowest_time > 0)
 195     {
 196       printf("---\n");
 197       printf("Slowest Server: %s (%d) => %ld.%ld seconds\n",
 198              memcached_server_name(memc, server_list[slowest_server]),
 199              memcached_server_port(memc, server_list[slowest_server]),
 200              slowest_time / 1000, slowest_time % 1000);
 201     }
 202     printf("\n");
 203
 204     for (x= 0; x < server_count; x++)
 205       memcached_free(servers[x]);
 206
 207     free(servers);
 208     free(analyze_mode);
 209   }
 210   else
 211   {
 212     fprintf(stderr, "Invalid Analyzer Option provided\n");
 213     free(analyze_mode);
 214   }
 215 }
 216
 217 static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
 218                                  memcached_server_st *server_list)
 219 {
 220   unsigned int x;
 221   memcached_return rc;
 222
 223   printf("Listing %u Server\n\n", memcached_server_count(memc));
 224   for (x= 0; x < memcached_server_count(memc); x++)
 225   {
 226     char **list;
 227     char **ptr;
 228
 229     list= memcached_stat_get_keys(memc, &stat[x], &rc);
 230
 231     printf("Server: %s (%u)\n", memcached_server_name(memc, server_list[x]),
 232            memcached_server_port(memc, server_list[x]));
 233     for (ptr= list; *ptr; ptr++)
 234     {
 235       memcached_return rc;
 236       char *value= memcached_stat_get_value(memc, &stat[x], *ptr, &rc);
 237
 238       printf("\t %s: %s\n", *ptr, value);
 239       free(value);
 240     }
 241
 242     free(list);
 243     printf("\n");
 244   }
 245 }
 246
 247 static void print_analysis_report(memcached_st *memc,
 248                                   memcached_analysis_st *report,
 249                                   memcached_server_st *server_list)
 250 {
 251   uint32_t server_count= memcached_server_count(memc);
 252
 253   printf("Memcached Cluster Analysis Report\n\n");
 254
 255   printf("\tNumber of Servers Analyzed         : %d\n", server_count);
 256   printf("\tAverage Item Size (incl/overhead)  : %u bytes\n",
 257          report->average_item_size);
 258
 259   if (server_count == 1)
 260   {
 261     printf("\nFor a detailed report, you must supply multiple servers.\n");
 262     return;
 263   }
 264
 265   printf("\n");
 266   printf("\tNode with most memory consumption  : %s:%u (%llu bytes)\n",
 267          memcached_server_name(memc, server_list[report->most_consumed_server]),
 268          memcached_server_port(memc, server_list[report->most_consumed_server]),
 269          (unsigned long long)report->most_used_bytes);
 270   printf("\tNode with least free space         : %s:%u (%llu bytes remaining)\n",
 271          memcached_server_name(memc, server_list[report->least_free_server]),
 272          memcached_server_port(memc, server_list[report->least_free_server]),
 273          (unsigned long long)report->least_remaining_bytes);
 274   printf("\tNode with longest uptime           : %s:%u (%us)\n",
 275          memcached_server_name(memc, server_list[report->oldest_server]),
 276          memcached_server_port(memc, server_list[report->oldest_server]),
 277          report->longest_uptime);
 278   printf("\tPool-wide Hit Ratio                : %1.f%%\n", report->pool_hit_ratio);
 279   printf("\n");
 280 }
 281
 282 static void options_parse(int argc, char *argv[])
 283 {
 284   memcached_programs_help_st help_options[]=
 285   {
 286     {0},
 287   };
 288
 289   int option_index= 0;
 290   int option_rv;
 291
 292   while (1)
 293   {
 294     option_rv= getopt_long(argc, argv, "Vhvds:a", long_options, &option_index);
 295     if (option_rv == -1) break;
 296     switch (option_rv)
 297     {
 298     case 0:
 299       break;
 300     case OPT_VERBOSE: /* --verbose or -v */
 301       opt_verbose = OPT_VERBOSE;
 302       break;
 303     case OPT_DEBUG: /* --debug or -d */
 304       opt_verbose = OPT_DEBUG;
 305       break;
 306     case OPT_VERSION: /* --version or -V */
 307       version_command(PROGRAM_NAME);
 308       break;
 309     case OPT_HELP: /* --help or -h */
 310       help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
 311       break;
 312     case OPT_SERVERS: /* --servers or -s */
 313       opt_servers= strdup(optarg);
 314       break;
 315     case OPT_ANALYZE: /* --analyze or -a */
 316       opt_analyze= OPT_ANALYZE;
 317       analyze_mode= (optarg) ? strdup(optarg) : NULL;
 318       break;
 319     case '?':
 320       /* getopt_long already printed an error message. */
 321       exit(1);
 322     default:
 323       abort();
 324     }
 325   }
 326 }