projects / m6w6 / libmemcached / blob
? search:


49dfab018e4ac37cddf3891ece763670902a15de
[m6w6/libmemcached] / libmemcached / stats.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following disclaimer
16 * in the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * * The names of its contributors may not be used to endorse or
20 * promote products derived from this software without specific prior
21 * written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 */
36
37 #include <libmemcached/common.h>
38
39 static const char *memcached_stat_keys[] = {
40 "pid",
41 "uptime",
42 "time",
43 "version",
44 "pointer_size",
45 "rusage_user",
46 "rusage_system",
47 "curr_items",
48 "total_items",
49 "bytes",
50 "curr_connections",
51 "total_connections",
52 "connection_structures",
53 "cmd_get",
54 "cmd_set",
55 "get_hits",
56 "get_misses",
57 "evictions",
58 "bytes_read",
59 "bytes_written",
60 "limit_maxbytes",
61 "threads",
62 NULL
63 };
64
65 struct local_context
66 {
67 memcached_stat_fn func;
68 void *context;
69 const char *args;
70 const size_t args_length;
71
72 local_context(memcached_stat_fn func_arg,
73 void *context_arg,
74 const char *args_arg,
75 const size_t args_length_arg) :
76 func(func_arg),
77 context(context_arg),
78 args(args_arg),
79 args_length(args_length_arg)
80 { }
81 };
82
83
84 static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key, const char *value)
85 {
86
87 if (strlen(key) < 1)
88 {
89 WATCHPOINT_STRING(key);
90 return MEMCACHED_UNKNOWN_STAT_KEY;
91 }
92 else if (strcmp("pid", key) == 0)
93 {
94 int64_t temp= strtoll(value, (char **)NULL, 10);
95
96 if (temp <= INT32_MAX and ( sizeof(pid_t) == sizeof(int32_t) ))
97 {
98 memc_stat->pid= temp;
99 }
100 else if (temp > -1)
101 {
102 memc_stat->pid= temp;
103 }
104 else
105 {
106 // If we got a value less then -1 then something went wrong in the
107 // protocol
108 }
109 }
110 else if (not strcmp("uptime", key))
111 {
112 memc_stat->uptime= strtoul(value, (char **)NULL, 10);
113 }
114 else if (not strcmp("time", key))
115 {
116 memc_stat->time= strtoul(value, (char **)NULL, 10);
117 }
118 else if (not strcmp("version", key))
119 {
120 memcpy(memc_stat->version, value, strlen(value));
121 memc_stat->version[strlen(value)]= 0;
122 }
123 else if (not strcmp("pointer_size", key))
124 {
125 memc_stat->pointer_size= strtoul(value, (char **)NULL, 10);
126 }
127 else if (not strcmp("rusage_user", key))
128 {
129 char *walk_ptr;
130 for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
131 *walk_ptr= 0;
132 walk_ptr++;
133 memc_stat->rusage_user_seconds= strtoul(value, (char **)NULL, 10);
134 memc_stat->rusage_user_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
135 }
136 else if (not strcmp("rusage_system", key))
137 {
138 char *walk_ptr;
139 for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
140 *walk_ptr= 0;
141 walk_ptr++;
142 memc_stat->rusage_system_seconds= strtoul(value, (char **)NULL, 10);
143 memc_stat->rusage_system_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
144 }
145 else if (not strcmp("curr_items", key))
146 {
147 memc_stat->curr_items= strtoul(value, (char **)NULL, 10);
148 }
149 else if (not strcmp("total_items", key))
150 {
151 memc_stat->total_items= strtoul(value, (char **)NULL, 10);
152 }
153 else if (not strcmp("bytes_read", key))
154 {
155 memc_stat->bytes_read= strtoull(value, (char **)NULL, 10);
156 }
157 else if (not strcmp("bytes_written", key))
158 {
159 memc_stat->bytes_written= strtoull(value, (char **)NULL, 10);
160 }
161 else if (not strcmp("bytes", key))
162 {
163 memc_stat->bytes= strtoull(value, (char **)NULL, 10);
164 }
165 else if (not strcmp("curr_connections", key))
166 {
167 memc_stat->curr_connections= strtoull(value, (char **)NULL, 10);
168 }
169 else if (not strcmp("total_connections", key))
170 {
171 memc_stat->total_connections= strtoull(value, (char **)NULL, 10);
172 }
173 else if (not strcmp("connection_structures", key))
174 {
175 memc_stat->connection_structures= strtoul(value, (char **)NULL, 10);
176 }
177 else if (not strcmp("cmd_get", key))
178 {
179 memc_stat->cmd_get= strtoull(value, (char **)NULL, 10);
180 }
181 else if (not strcmp("cmd_set", key))
182 {
183 memc_stat->cmd_set= strtoull(value, (char **)NULL, 10);
184 }
185 else if (not strcmp("get_hits", key))
186 {
187 memc_stat->get_hits= strtoull(value, (char **)NULL, 10);
188 }
189 else if (not strcmp("get_misses", key))
190 {
191 memc_stat->get_misses= strtoull(value, (char **)NULL, 10);
192 }
193 else if (not strcmp("evictions", key))
194 {
195 memc_stat->evictions= strtoull(value, (char **)NULL, 10);
196 }
197 else if (not strcmp("limit_maxbytes", key))
198 {
199 memc_stat->limit_maxbytes= strtoull(value, (char **)NULL, 10);
200 }
201 else if (not strcmp("threads", key))
202 {
203 memc_stat->threads= strtoul(value, (char **)NULL, 10);
204 }
205 else if (not (strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */
206 strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */
207 strcmp("incr_misses", key) == 0 or
208 strcmp("incr_hits", key) == 0 or
209 strcmp("decr_misses", key) == 0 or
210 strcmp("decr_hits", key) == 0 or
211 strcmp("cas_misses", key) == 0 or
212 strcmp("cas_hits", key) == 0 or
213 strcmp("cas_badval", key) == 0 or
214 strcmp("cmd_flush", key) == 0 or
215 strcmp("accepting_conns", key) == 0 or
216 strcmp("listen_disabled_num", key) == 0 or
217 strcmp("conn_yields", key) == 0 or
218 strcmp("auth_cmds", key) == 0 or
219 strcmp("auth_errors", key) == 0 or
220 strcmp("reclaimed", key) == 0))
221 {
222 WATCHPOINT_STRING(key);
223 /* return MEMCACHED_UNKNOWN_STAT_KEY; */
224 return MEMCACHED_SUCCESS;
225 }
226
227 return MEMCACHED_SUCCESS;
228 }
229
230 char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_stat,
231 const char *key, memcached_return_t *error)
232 {
233 char buffer[SMALL_STRING_LEN];
234 int length;
235 char *ret;
236
237 *error= MEMCACHED_SUCCESS;
238
239 if (memcmp("pid", key, sizeof("pid") -1) == 0)
240 {
241 length= snprintf(buffer, SMALL_STRING_LEN,"%lld", (signed long long)memc_stat->pid);
242 }
243 else if (not memcmp("uptime", key, sizeof("uptime") -1))
244 {
245 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->uptime);
246 }
247 else if (not memcmp("time", key, sizeof("time") -1))
248 {
249 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->time);
250 }
251 else if (not memcmp("version", key, sizeof("version") -1))
252 {
253 length= snprintf(buffer, SMALL_STRING_LEN,"%s", memc_stat->version);
254 }
255 else if (not memcmp("pointer_size", key, sizeof("pointer_size") -1))
256 {
257 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->pointer_size);
258 }
259 else if (not memcmp("rusage_user", key, sizeof("rusage_user") -1))
260 {
261 length= snprintf(buffer, SMALL_STRING_LEN,"%lu.%lu", memc_stat->rusage_user_seconds, memc_stat->rusage_user_microseconds);
262 }
263 else if (not memcmp("rusage_system", key, sizeof("rusage_system") -1))
264 {
265 length= snprintf(buffer, SMALL_STRING_LEN,"%lu.%lu", memc_stat->rusage_system_seconds, memc_stat->rusage_system_microseconds);
266 }
267 else if (not memcmp("curr_items", key, sizeof("curr_items") -1))
268 {
269 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->curr_items);
270 }
271 else if (not memcmp("total_items", key, sizeof("total_items") -1))
272 {
273 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->total_items);
274 }
275 else if (not memcmp("curr_connections", key, sizeof("curr_connections") -1))
276 {
277 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->curr_connections);
278 }
279 else if (not memcmp("total_connections", key, sizeof("total_connections") -1))
280 {
281 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->total_connections);
282 }
283 else if (not memcmp("connection_structures", key, sizeof("connection_structures") -1))
284 {
285 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->connection_structures);
286 }
287 else if (not memcmp("cmd_get", key, sizeof("cmd_get") -1))
288 {
289 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->cmd_get);
290 }
291 else if (not memcmp("cmd_set", key, sizeof("cmd_set") -1))
292 {
293 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->cmd_set);
294 }
295 else if (not memcmp("get_hits", key, sizeof("get_hits") -1))
296 {
297 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->get_hits);
298 }
299 else if (not memcmp("get_misses", key, sizeof("get_misses") -1))
300 {
301 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->get_misses);
302 }
303 else if (not memcmp("evictions", key, sizeof("evictions") -1))
304 {
305 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->evictions);
306 }
307 else if (not memcmp("bytes_read", key, sizeof("bytes_read") -1))
308 {
309 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes_read);
310 }
311 else if (not memcmp("bytes_written", key, sizeof("bytes_written") -1))
312 {
313 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes_written);
314 }
315 else if (not memcmp("bytes", key, sizeof("bytes") -1))
316 {
317 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes);
318 }
319 else if (not memcmp("limit_maxbytes", key, sizeof("limit_maxbytes") -1))
320 {
321 length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->limit_maxbytes);
322 }
323 else if (not memcmp("threads", key, sizeof("threads") -1))
324 {
325 length= snprintf(buffer, SMALL_STRING_LEN,"%lu", memc_stat->threads);
326 }
327 else
328 {
329 *error= MEMCACHED_NOTFOUND;
330 return NULL;
331 }
332
333 if (length >= SMALL_STRING_LEN || length < 0)
334 {
335 *error= MEMCACHED_FAILURE;
336 return NULL;
337 }
338
339 ret= static_cast<char *>(libmemcached_malloc(ptr, (size_t) (length + 1)));
340 memcpy(ret, buffer, (size_t) length);
341 ret[length]= '\0';
342
343 return ret;
344 }
345
346 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
347 const char *args,
348 const size_t args_length,
349 memcached_server_write_instance_st instance,
350 struct local_context *check)
351 {
352 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
353 protocol_binary_request_stats request= {}; // = {.bytes= {0}};
354 request.message.header.request.magic= PROTOCOL_BINARY_REQ;
355 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_STAT;
356 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
357
358 if (args_length)
359 {
360 request.message.header.request.keylen= htons(uint16_t(args_length));
361 request.message.header.request.bodylen= htonl(uint32_t( args_length));
362
363 libmemcached_io_vector_st vector[]=
364 {
365 { request.bytes, sizeof(request.bytes) },
366 { args, args_length }
367 };
368
369 if (memcached_vdo(instance, vector, 2, true) != MEMCACHED_SUCCESS)
370 {
371 memcached_io_reset(instance);
372 return MEMCACHED_WRITE_FAILURE;
373 }
374 }
375 else
376 {
377 libmemcached_io_vector_st vector[]=
378 {
379 { request.bytes, sizeof(request.bytes) }
380 };
381
382 if (memcached_vdo(instance, vector, 1, true) != MEMCACHED_SUCCESS)
383 {
384 memcached_io_reset(instance);
385 return MEMCACHED_WRITE_FAILURE;
386 }
387 }
388
389 memcached_server_response_decrement(instance);
390 do
391 {
392 memcached_return_t rc= memcached_response(instance, buffer, sizeof(buffer), NULL);
393
394 if (rc == MEMCACHED_END)
395 {
396 break;
397 }
398
399 if (rc != MEMCACHED_SUCCESS)
400 {
401 memcached_io_reset(instance);
402 return rc;
403 }
404
405 if (check && check->func)
406 {
407 size_t key_length= strlen(buffer);
408
409 check->func(instance,
410 buffer, key_length,
411 buffer+key_length+1, strlen(buffer+key_length+1),
412 check->context);
413 }
414
415 if (memc_stat)
416 {
417 if ((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
418 {
419 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
420 WATCHPOINT_ASSERT(0);
421 }
422 }
423 } while (1);
424
425 /*
426 * memcached_response will decrement the counter, so I need to reset it..
427 * todo: look at this and try to find a better solution.
428 * */
429 instance->cursor_active= 0;
430
431 return MEMCACHED_SUCCESS;
432 }
433
434 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
435 const char *args,
436 const size_t args_length,
437 memcached_server_write_instance_st instance,
438 struct local_context *check)
439 {
440 libmemcached_io_vector_st vector[]=
441 {
442 { memcached_literal_param("stats ") },
443 { args, args_length },
444 { memcached_literal_param("\r\n") }
445 };
446
447 memcached_return_t rc= memcached_vdo(instance, vector, 3, true);
448 if (memcached_success(rc))
449 {
450 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
451 while ((rc= memcached_response(instance, buffer, sizeof(buffer), NULL)) == MEMCACHED_STAT)
452 {
453 char *string_ptr= buffer;
454 string_ptr+= 5; /* Move past STAT */
455
456 char *end_ptr;
457 for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++) {};
458 char *key= string_ptr;
459 key[size_t(end_ptr-string_ptr)]= 0;
460
461 string_ptr= end_ptr + 1;
462 for (end_ptr= string_ptr; !(isspace(*end_ptr)); end_ptr++) {};
463 char *value= string_ptr;
464 value[(size_t)(end_ptr -string_ptr)]= 0;
465 #if 0
466 bool check_bool= bool(check);
467 bool check_func_bool= bool(check) ? bool(check->func) : false;
468 fprintf(stderr, "%s:%d %s %s %d:%d\n", __FILE__, __LINE__, key, value, check_bool, check_func_bool);
469 #endif
470
471 if (check and check->func)
472 {
473 check->func(instance,
474 key, strlen(key),
475 value, strlen(value),
476 check->context);
477 }
478
479 if (memc_stat)
480 {
481 if((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
482 {
483 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
484 WATCHPOINT_ASSERT(0);
485 }
486 }
487 }
488 }
489
490 if (rc == MEMCACHED_ERROR)
491 {
492 return MEMCACHED_INVALID_ARGUMENTS;
493 }
494
495 if (rc == MEMCACHED_END)
496 {
497 return MEMCACHED_SUCCESS;
498 }
499
500 return rc;
501 }
502
503 memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_return_t *error)
504 {
505 memcached_return_t unused;
506 if (error == NULL)
507 {
508 error= &unused;
509 }
510
511 if (memcached_failed(*error= initialize_query(self, true)))
512 {
513 return NULL;
514 }
515
516 if (memcached_is_udp(self))
517 {
518 *error= memcached_set_error(*self, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
519 return NULL;
520 }
521
522 memcached_return_t rc;
523 size_t args_length= 0;
524 if (args)
525 {
526 args_length= strlen(args);
527 rc= memcached_validate_key_length(args_length, self->flags.binary_protocol);
528 if (memcached_failed(rc))
529 {
530 *error= memcached_set_error(*self, rc, MEMCACHED_AT);
531 return NULL;
532 }
533 }
534
535 WATCHPOINT_ASSERT(error);
536
537 memcached_stat_st *stats= libmemcached_xcalloc(self, memcached_server_count(self), memcached_stat_st);
538 if (stats == NULL)
539 {
540 *error= memcached_set_error(*self, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
541 return NULL;
542 }
543
544 WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS);
545 rc= MEMCACHED_SUCCESS;
546 for (uint32_t x= 0; x < memcached_server_count(self); x++)
547 {
548 memcached_stat_st* stat_instance= stats +x;
549
550 stat_instance->pid= -1;
551 stat_instance->root= self;
552
553 memcached_server_write_instance_st instance= memcached_server_instance_fetch(self, x);
554
555 memcached_return_t temp_return;
556 if (memcached_is_binary(self))
557 {
558 temp_return= binary_stats_fetch(stat_instance, args, args_length, instance, NULL);
559 }
560 else
561 {
562 temp_return= ascii_stats_fetch(stat_instance, args, args_length, instance, NULL);
563 }
564
565 // Special case where "args" is invalid
566 if (temp_return == MEMCACHED_INVALID_ARGUMENTS)
567 {
568 rc= MEMCACHED_INVALID_ARGUMENTS;
569 break;
570 }
571
572 if (memcached_failed(temp_return))
573 {
574 rc= MEMCACHED_SOME_ERRORS;
575 }
576 }
577
578 *error= rc;
579
580 return stats;
581 }
582
583 memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
584 const char *hostname, in_port_t port)
585 {
586 memcached_st memc;
587
588 memset(memc_stat, 0, sizeof(memcached_stat_st));
589
590 memcached_st *memc_ptr= memcached_create(&memc);
591 if (memc_ptr == NULL)
592 {
593 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
594 }
595
596 memcached_return_t rc;
597 if (memcached_failed(rc= memcached_server_add(&memc, hostname, port)))
598 {
599 memcached_free(&memc);
600 return rc;
601 }
602
603 if (memcached_success(rc= initialize_query(memc_ptr, true)))
604 {
605 size_t args_length= 0;
606 if (args)
607 {
608 args_length= strlen(args);
609 rc= memcached_validate_key_length(args_length, memc.flags.binary_protocol);
610 }
611
612 if (memcached_success(rc))
613 {
614 memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc_ptr, 0);
615 if (memc.flags.binary_protocol)
616 {
617 rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL);
618 }
619 else
620 {
621 rc= ascii_stats_fetch(memc_stat, args, args_length, instance, NULL);
622 }
623 }
624 }
625
626 memcached_free(&memc);
627
628 return rc;
629 }
630
631 /*
632 We make a copy of the keys since at some point in the not so distant future
633 we will add support for "found" keys.
634 */
635 char ** memcached_stat_get_keys(memcached_st *ptr,
636 memcached_stat_st *,
637 memcached_return_t *error)
638 {
639 if (ptr == NULL)
640 {
641 return NULL;
642 }
643
644 char **list= static_cast<char **>(libmemcached_malloc(ptr, sizeof(memcached_stat_keys)));
645 if (not list)
646 {
647 *error= memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
648 return NULL;
649 }
650
651 memcpy(list, memcached_stat_keys, sizeof(memcached_stat_keys));
652
653 *error= MEMCACHED_SUCCESS;
654
655 return list;
656 }
657
658 void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat)
659 {
660 WATCHPOINT_ASSERT(memc_stat); // Be polite, but when debugging catch this as an error
661 if (memc_stat == NULL)
662 {
663 return;
664 }
665
666 if (memc_stat->root)
667 {
668 libmemcached_free(memc_stat->root, memc_stat);
669 return;
670 }
671
672 libmemcached_free(NULL, memc_stat);
673 }
674
675 static memcached_return_t call_stat_fn(memcached_st *ptr,
676 memcached_server_write_instance_st instance,
677 void *context)
678 {
679 memcached_return_t rc;
680 local_context *check= (struct local_context *)context;
681
682 if (memcached_is_binary(ptr))
683 {
684 rc= binary_stats_fetch(NULL, check->args, check->args_length, instance, check);
685 }
686 else
687 {
688 rc= ascii_stats_fetch(NULL, check->args, check->args_length, instance, check);
689 }
690
691 return rc;
692 }
693
694 memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args, memcached_stat_fn func, void *context)
695 {
696 memcached_version(memc);
697
698 local_context check(func, context, args, args ? strlen(args) : 0);
699
700 return memcached_server_execute(memc, call_stat_fn, (void *)&check);
701 }
Resurrection of libmemcached https://launchpad.net/libmemcached