Updating memcached_server_instance_st structure.

[awesomized/libmemcached] / clients / memstat.c

diff --git a/clients/memstat.c b/clients/memstat.c
index 27c34a41c2caf4ad048c3bb4f8320cfe5950142a..ceaba36f4da9c5ef7a60ad6e93b048c7807ab781 100644 (file)
--- a/clients/memstat.c
+++ b/clients/memstat.c
@@ -1,3 +1,17 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ * Authors: 
+ *          Brian Aker
+ *          Toru Maesaka
+ */
+
 #include "libmemcached/common.h"
 #include <stdio.h>
 #include <sys/types.h>
@@ -35,19 +49,19 @@ static char *analyze_mode= NULL;
 
 static struct option long_options[]=
 {
-  {"version", no_argument, NULL, OPT_VERSION},
-  {"help", no_argument, NULL, OPT_HELP},
-  {"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
-  {"debug", no_argument, &opt_verbose, OPT_DEBUG},
-  {"servers", required_argument, NULL, OPT_SERVERS},
-  {"flag", no_argument, &opt_displayflag, OPT_FLAG},
-  {"analyze", optional_argument, NULL, OPT_ANALYZE},
+  {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
+  {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+  {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
+  {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
+  {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
+  {(OPTIONSTRING)"flag", no_argument, &opt_displayflag, OPT_FLAG},
+  {(OPTIONSTRING)"analyze", optional_argument, NULL, OPT_ANALYZE},
   {0, 0, 0, 0},
 };
 
 int main(int argc, char *argv[])
 {
-  memcached_return rc;
+  memcached_return_t rc;
   memcached_st *memc;
   memcached_stat_st *memc_stat;
   memcached_server_st *servers;
@@ -102,7 +116,7 @@ int main(int argc, char *argv[])
 static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
                          memcached_server_st *server_list)
 {
-  memcached_return rc;
+  memcached_return_t rc;
 
   if (analyze_mode == NULL)
   {
@@ -120,7 +134,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
   else if (strcmp(analyze_mode, "latency") == 0)
   {
     memcached_st **servers;
-    uint32_t x, y, flags, server_count= memcached_server_count(memc);
+    uint32_t flags, server_count= memcached_server_count(memc);
     uint32_t num_of_tests= 32;
     const char *test_key= "libmemcached_test_key";
 
@@ -131,7 +145,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
       return;
     }
 
-    for (x= 0; x < server_count; x++)
+    for (uint32_t x= 0; x < server_count; x++)
     {
       if((servers[x]= memcached_create(NULL)) == NULL)
       {
@@ -146,18 +160,18 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
         return;
       }
       memcached_server_add(servers[x],
-                           memcached_server_name(memc, server_list[x]),
-                           memcached_server_port(memc, server_list[x]));
+                           memcached_server_name(&server_list[x]),
+                           memcached_server_port(&server_list[x]));
     }
 
     printf("Network Latency Test:\n\n");
     struct timeval start_time, end_time;
     long elapsed_time, slowest_time= 0, slowest_server= 0;
 
-    for (x= 0; x < server_count; x++)
+    for (uint32_t x= 0; x < server_count; x++)
     {
       gettimeofday(&start_time, NULL);
-      for (y= 0; y < num_of_tests; y++)
+      for (uint32_t y= 0; y < num_of_tests; y++)
       {
         size_t vlen;
         char *val= memcached_get(servers[x], test_key, strlen(test_key),
@@ -168,26 +182,26 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
       }
       gettimeofday(&end_time, NULL);
 
-      elapsed_time= timedif(end_time, start_time);
-      elapsed_time /= num_of_tests;
+      elapsed_time= (long) timedif(end_time, start_time);
+      elapsed_time /= (long) num_of_tests;
 
       if (elapsed_time > slowest_time)
       {
-        slowest_server= x;
+        slowest_server= (long)x;
         slowest_time= elapsed_time;
       }
 
       if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
       {
         printf("\t %s (%d)  =>  failed to reach the server\n",
-               memcached_server_name(memc, server_list[x]),
-               memcached_server_port(memc, server_list[x]));
+               memcached_server_name(&server_list[x]),
+               memcached_server_port(&server_list[x]));
       }
       else
       {
         printf("\t %s (%d)  =>  %ld.%ld seconds\n",
-               memcached_server_name(memc, server_list[x]),
-               memcached_server_port(memc, server_list[x]),
+               memcached_server_name(&server_list[x]),
+               memcached_server_port(&server_list[x]),
                elapsed_time / 1000, elapsed_time % 1000);
       }
     }
@@ -196,13 +210,13 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
     {
       printf("---\n");
       printf("Slowest Server: %s (%d) => %ld.%ld seconds\n",
-             memcached_server_name(memc, server_list[slowest_server]),
-             memcached_server_port(memc, server_list[slowest_server]),
+             memcached_server_name(&server_list[slowest_server]),
+             memcached_server_port(&server_list[slowest_server]),
              slowest_time / 1000, slowest_time % 1000);
     }
     printf("\n");
 
-    for (x= 0; x < server_count; x++)
+    for (uint32_t x= 0; x < server_count; x++)
       memcached_free(servers[x]);
 
     free(servers);
@@ -218,19 +232,18 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
 static void print_server_listing(memcached_st *memc, memcached_stat_st *memc_stat,
                                  memcached_server_st *server_list)
 {
-  unsigned int x;
-  memcached_return rc;
+  memcached_return_t rc;
 
   printf("Listing %u Server\n\n", memcached_server_count(memc));
-  for (x= 0; x < memcached_server_count(memc); x++)
+  for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
     char **list;
     char **ptr;
 
     list= memcached_stat_get_keys(memc, &memc_stat[x], &rc);
 
-    printf("Server: %s (%u)\n", memcached_server_name(memc, server_list[x]),
-           memcached_server_port(memc, server_list[x]));
+    printf("Server: %s (%u)\n", memcached_server_name(&server_list[x]),
+           (uint32_t)memcached_server_port(&server_list[x]));
     for (ptr= list; *ptr; ptr++)
     {
       char *value= memcached_stat_get_value(memc, &memc_stat[x], *ptr, &rc);
@@ -252,7 +265,7 @@ static void print_analysis_report(memcached_st *memc,
 
   printf("Memcached Cluster Analysis Report\n\n");
 
-  printf("\tNumber of Servers Analyzed         : %d\n", server_count);
+  printf("\tNumber of Servers Analyzed         : %u\n", server_count);
   printf("\tAverage Item Size (incl/overhead)  : %u bytes\n",
          report->average_item_size);
 
@@ -264,16 +277,16 @@ static void print_analysis_report(memcached_st *memc,
 
   printf("\n");
   printf("\tNode with most memory consumption  : %s:%u (%llu bytes)\n",
-         memcached_server_name(memc, server_list[report->most_consumed_server]),
-         memcached_server_port(memc, server_list[report->most_consumed_server]),
+         memcached_server_name(&server_list[report->most_consumed_server]),
+         (uint32_t)memcached_server_port(&server_list[report->most_consumed_server]),
          (unsigned long long)report->most_used_bytes);
   printf("\tNode with least free space         : %s:%u (%llu bytes remaining)\n",
-         memcached_server_name(memc, server_list[report->least_free_server]),
-         memcached_server_port(memc, server_list[report->least_free_server]),
+         memcached_server_name(&server_list[report->least_free_server]),
+         (uint32_t)memcached_server_port(&server_list[report->least_free_server]),
          (unsigned long long)report->least_remaining_bytes);
   printf("\tNode with longest uptime           : %s:%u (%us)\n",
-         memcached_server_name(memc, server_list[report->oldest_server]),
-         memcached_server_port(memc, server_list[report->oldest_server]),
+         memcached_server_name(&server_list[report->oldest_server]),
+         (uint32_t)memcached_server_port(&server_list[report->oldest_server]),
          report->longest_uptime);
   printf("\tPool-wide Hit Ratio                : %1.f%%\n", report->pool_hit_ratio);
   printf("\n");