1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
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
19 * * The names of its contributors may not be used to endorse or
20 * promote products derived from this software without specific prior
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.
37 #include <libmemcached/common.h>
39 static const char *memcached_stat_keys
[] = {
52 "connection_structures",
67 memcached_stat_fn func
;
70 const size_t args_length
;
72 local_context(memcached_stat_fn func_arg
,
75 const size_t args_length_arg
) :
79 args_length(args_length_arg
)
84 static memcached_return_t
set_data(memcached_stat_st
*memc_stat
, const char *key
, const char *value
)
89 WATCHPOINT_STRING(key
);
90 return MEMCACHED_UNKNOWN_STAT_KEY
;
92 else if (strcmp("pid", key
) == 0)
94 int64_t temp
= strtoll(value
, (char **)NULL
, 10);
96 if (temp
<= INT32_MAX
and ( sizeof(pid_t
) == sizeof(int32_t) ))
98 memc_stat
->pid
= pid_t(temp
);
102 memc_stat
->pid
= pid_t(temp
);
106 // If we got a value less then -1 then something went wrong in the
110 else if (not strcmp("uptime", key
))
112 memc_stat
->uptime
= strtoul(value
, (char **)NULL
, 10);
114 else if (not strcmp("time", key
))
116 memc_stat
->time
= strtoul(value
, (char **)NULL
, 10);
118 else if (not strcmp("version", key
))
120 memcpy(memc_stat
->version
, value
, strlen(value
));
121 memc_stat
->version
[strlen(value
)]= 0;
123 else if (not strcmp("pointer_size", key
))
125 memc_stat
->pointer_size
= strtoul(value
, (char **)NULL
, 10);
127 else if (not strcmp("rusage_user", key
))
130 for (walk_ptr
= (char*)value
; (!ispunct(*walk_ptr
)); 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);
136 else if (not strcmp("rusage_system", key
))
139 for (walk_ptr
= (char*)value
; (!ispunct(*walk_ptr
)); 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);
145 else if (not strcmp("curr_items", key
))
147 memc_stat
->curr_items
= strtoul(value
, (char **)NULL
, 10);
149 else if (not strcmp("total_items", key
))
151 memc_stat
->total_items
= strtoul(value
, (char **)NULL
, 10);
153 else if (not strcmp("bytes_read", key
))
155 memc_stat
->bytes_read
= strtoull(value
, (char **)NULL
, 10);
157 else if (not strcmp("bytes_written", key
))
159 memc_stat
->bytes_written
= strtoull(value
, (char **)NULL
, 10);
161 else if (not strcmp("bytes", key
))
163 memc_stat
->bytes
= strtoull(value
, (char **)NULL
, 10);
165 else if (not strcmp("curr_connections", key
))
167 memc_stat
->curr_connections
= strtoull(value
, (char **)NULL
, 10);
169 else if (not strcmp("total_connections", key
))
171 memc_stat
->total_connections
= strtoull(value
, (char **)NULL
, 10);
173 else if (not strcmp("connection_structures", key
))
175 memc_stat
->connection_structures
= strtoul(value
, (char **)NULL
, 10);
177 else if (not strcmp("cmd_get", key
))
179 memc_stat
->cmd_get
= strtoull(value
, (char **)NULL
, 10);
181 else if (not strcmp("cmd_set", key
))
183 memc_stat
->cmd_set
= strtoull(value
, (char **)NULL
, 10);
185 else if (not strcmp("get_hits", key
))
187 memc_stat
->get_hits
= strtoull(value
, (char **)NULL
, 10);
189 else if (not strcmp("get_misses", key
))
191 memc_stat
->get_misses
= strtoull(value
, (char **)NULL
, 10);
193 else if (not strcmp("evictions", key
))
195 memc_stat
->evictions
= strtoull(value
, (char **)NULL
, 10);
197 else if (not strcmp("limit_maxbytes", key
))
199 memc_stat
->limit_maxbytes
= strtoull(value
, (char **)NULL
, 10);
201 else if (not strcmp("threads", key
))
203 memc_stat
->threads
= strtoul(value
, (char **)NULL
, 10);
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))
222 WATCHPOINT_STRING(key
);
223 /* return MEMCACHED_UNKNOWN_STAT_KEY; */
224 return MEMCACHED_SUCCESS
;
227 return MEMCACHED_SUCCESS
;
230 char *memcached_stat_get_value(const memcached_st
*ptr
, memcached_stat_st
*memc_stat
,
231 const char *key
, memcached_return_t
*error
)
233 char buffer
[SMALL_STRING_LEN
];
237 *error
= MEMCACHED_SUCCESS
;
239 if (memcmp("pid", key
, sizeof("pid") -1) == 0)
241 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lld", (signed long long)memc_stat
->pid
);
243 else if (not memcmp("uptime", key
, sizeof("uptime") -1))
245 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->uptime
);
247 else if (not memcmp("time", key
, sizeof("time") -1))
249 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->time
);
251 else if (not memcmp("version", key
, sizeof("version") -1))
253 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%s", memc_stat
->version
);
255 else if (not memcmp("pointer_size", key
, sizeof("pointer_size") -1))
257 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->pointer_size
);
259 else if (not memcmp("rusage_user", key
, sizeof("rusage_user") -1))
261 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu.%lu", memc_stat
->rusage_user_seconds
, memc_stat
->rusage_user_microseconds
);
263 else if (not memcmp("rusage_system", key
, sizeof("rusage_system") -1))
265 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu.%lu", memc_stat
->rusage_system_seconds
, memc_stat
->rusage_system_microseconds
);
267 else if (not memcmp("curr_items", key
, sizeof("curr_items") -1))
269 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->curr_items
);
271 else if (not memcmp("total_items", key
, sizeof("total_items") -1))
273 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->total_items
);
275 else if (not memcmp("curr_connections", key
, sizeof("curr_connections") -1))
277 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->curr_connections
);
279 else if (not memcmp("total_connections", key
, sizeof("total_connections") -1))
281 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->total_connections
);
283 else if (not memcmp("connection_structures", key
, sizeof("connection_structures") -1))
285 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->connection_structures
);
287 else if (not memcmp("cmd_get", key
, sizeof("cmd_get") -1))
289 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->cmd_get
);
291 else if (not memcmp("cmd_set", key
, sizeof("cmd_set") -1))
293 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->cmd_set
);
295 else if (not memcmp("get_hits", key
, sizeof("get_hits") -1))
297 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->get_hits
);
299 else if (not memcmp("get_misses", key
, sizeof("get_misses") -1))
301 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->get_misses
);
303 else if (not memcmp("evictions", key
, sizeof("evictions") -1))
305 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->evictions
);
307 else if (not memcmp("bytes_read", key
, sizeof("bytes_read") -1))
309 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes_read
);
311 else if (not memcmp("bytes_written", key
, sizeof("bytes_written") -1))
313 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes_written
);
315 else if (not memcmp("bytes", key
, sizeof("bytes") -1))
317 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes
);
319 else if (not memcmp("limit_maxbytes", key
, sizeof("limit_maxbytes") -1))
321 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->limit_maxbytes
);
323 else if (not memcmp("threads", key
, sizeof("threads") -1))
325 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%lu", memc_stat
->threads
);
329 *error
= MEMCACHED_NOTFOUND
;
333 if (length
>= SMALL_STRING_LEN
|| length
< 0)
335 *error
= MEMCACHED_FAILURE
;
339 ret
= static_cast<char *>(libmemcached_malloc(ptr
, (size_t) (length
+ 1)));
340 memcpy(ret
, buffer
, (size_t) length
);
346 static memcached_return_t
binary_stats_fetch(memcached_stat_st
*memc_stat
,
348 const size_t args_length
,
349 org::libmemcached::Instance
* instance
,
350 struct local_context
*check
)
352 char buffer
[MEMCACHED_DEFAULT_COMMAND_SIZE
];
353 protocol_binary_request_stats request
= {}; // = {.bytes= {0}};
355 initialize_binary_request(instance
, request
.message
.header
);
357 request
.message
.header
.request
.opcode
= PROTOCOL_BINARY_CMD_STAT
;
358 request
.message
.header
.request
.datatype
= PROTOCOL_BINARY_RAW_BYTES
;
362 request
.message
.header
.request
.keylen
= htons(uint16_t(args_length
));
363 request
.message
.header
.request
.bodylen
= htonl(uint32_t( args_length
));
365 libmemcached_io_vector_st vector
[]=
367 { request
.bytes
, sizeof(request
.bytes
) },
368 { args
, args_length
}
371 if (memcached_vdo(instance
, vector
, 2, true) != MEMCACHED_SUCCESS
)
373 memcached_io_reset(instance
);
374 return MEMCACHED_WRITE_FAILURE
;
379 libmemcached_io_vector_st vector
[]=
381 { request
.bytes
, sizeof(request
.bytes
) }
384 if (memcached_vdo(instance
, vector
, 1, true) != MEMCACHED_SUCCESS
)
386 memcached_io_reset(instance
);
387 return MEMCACHED_WRITE_FAILURE
;
391 memcached_server_response_decrement(instance
);
394 memcached_return_t rc
= memcached_response(instance
, buffer
, sizeof(buffer
), NULL
);
396 if (rc
== MEMCACHED_END
)
401 if (rc
!= MEMCACHED_SUCCESS
)
403 memcached_io_reset(instance
);
407 if (check
&& check
->func
)
409 size_t key_length
= strlen(buffer
);
411 check
->func(instance
,
413 buffer
+key_length
+1, strlen(buffer
+key_length
+1),
419 if ((set_data(memc_stat
, buffer
, buffer
+ strlen(buffer
) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY
)
421 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY
);
422 WATCHPOINT_ASSERT(0);
428 * memcached_response will decrement the counter, so I need to reset it..
429 * todo: look at this and try to find a better solution.
431 instance
->cursor_active_
= 0;
433 return MEMCACHED_SUCCESS
;
436 static memcached_return_t
ascii_stats_fetch(memcached_stat_st
*memc_stat
,
438 const size_t args_length
,
439 org::libmemcached::Instance
* instance
,
440 struct local_context
*check
)
442 libmemcached_io_vector_st vector
[]=
444 { memcached_literal_param("stats ") },
445 { args
, args_length
},
446 { memcached_literal_param("\r\n") }
449 memcached_return_t rc
= memcached_vdo(instance
, vector
, 3, true);
450 if (memcached_success(rc
))
452 char buffer
[MEMCACHED_DEFAULT_COMMAND_SIZE
];
453 while ((rc
= memcached_response(instance
, buffer
, sizeof(buffer
), NULL
)) == MEMCACHED_STAT
)
455 char *string_ptr
= buffer
;
456 string_ptr
+= 5; /* Move past STAT */
459 for (end_ptr
= string_ptr
; isgraph(*end_ptr
); end_ptr
++) {};
460 char *key
= string_ptr
;
461 key
[size_t(end_ptr
-string_ptr
)]= 0;
463 string_ptr
= end_ptr
+ 1;
464 for (end_ptr
= string_ptr
; !(isspace(*end_ptr
)); end_ptr
++) {};
465 char *value
= string_ptr
;
466 value
[(size_t)(end_ptr
-string_ptr
)]= 0;
468 bool check_bool
= bool(check
);
469 bool check_func_bool
= bool(check
) ? bool(check
->func
) : false;
470 fprintf(stderr
, "%s:%d %s %s %d:%d\n", __FILE__
, __LINE__
, key
, value
, check_bool
, check_func_bool
);
473 if (check
and check
->func
)
475 check
->func(instance
,
477 value
, strlen(value
),
483 if((set_data(memc_stat
, key
, value
)) == MEMCACHED_UNKNOWN_STAT_KEY
)
485 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY
);
486 WATCHPOINT_ASSERT(0);
492 if (rc
== MEMCACHED_ERROR
)
494 return MEMCACHED_INVALID_ARGUMENTS
;
497 if (rc
== MEMCACHED_END
)
499 return MEMCACHED_SUCCESS
;
505 memcached_stat_st
*memcached_stat(memcached_st
*self
, char *args
, memcached_return_t
*error
)
507 memcached_return_t unused
;
513 if (memcached_failed(*error
= initialize_query(self
, true)))
518 if (memcached_is_udp(self
))
520 *error
= memcached_set_error(*self
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
524 memcached_return_t rc
;
525 size_t args_length
= 0;
528 args_length
= strlen(args
);
529 rc
= memcached_validate_key_length(args_length
, self
->flags
.binary_protocol
);
530 if (memcached_failed(rc
))
532 *error
= memcached_set_error(*self
, rc
, MEMCACHED_AT
);
537 WATCHPOINT_ASSERT(error
);
539 memcached_stat_st
*stats
= libmemcached_xcalloc(self
, memcached_server_count(self
), memcached_stat_st
);
542 *error
= memcached_set_error(*self
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
546 WATCHPOINT_ASSERT(rc
== MEMCACHED_SUCCESS
);
547 rc
= MEMCACHED_SUCCESS
;
548 for (uint32_t x
= 0; x
< memcached_server_count(self
); x
++)
550 memcached_stat_st
* stat_instance
= stats
+x
;
552 stat_instance
->pid
= -1;
553 stat_instance
->root
= self
;
555 org::libmemcached::Instance
* instance
= memcached_instance_fetch(self
, x
);
557 memcached_return_t temp_return
;
558 if (memcached_is_binary(self
))
560 temp_return
= binary_stats_fetch(stat_instance
, args
, args_length
, instance
, NULL
);
564 temp_return
= ascii_stats_fetch(stat_instance
, args
, args_length
, instance
, NULL
);
567 // Special case where "args" is invalid
568 if (temp_return
== MEMCACHED_INVALID_ARGUMENTS
)
570 rc
= MEMCACHED_INVALID_ARGUMENTS
;
574 if (memcached_failed(temp_return
))
576 rc
= MEMCACHED_SOME_ERRORS
;
585 memcached_return_t
memcached_stat_servername(memcached_stat_st
*memc_stat
, char *args
,
586 const char *hostname
, in_port_t port
)
590 memset(memc_stat
, 0, sizeof(memcached_stat_st
));
592 memcached_st
*memc_ptr
= memcached_create(&memc
);
593 if (memc_ptr
== NULL
)
595 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
598 memcached_return_t rc
;
599 if (memcached_failed(rc
= memcached_server_add(&memc
, hostname
, port
)))
601 memcached_free(&memc
);
605 if (memcached_success(rc
= initialize_query(memc_ptr
, true)))
607 size_t args_length
= 0;
610 args_length
= strlen(args
);
611 rc
= memcached_validate_key_length(args_length
, memc
.flags
.binary_protocol
);
614 if (memcached_success(rc
))
616 org::libmemcached::Instance
* instance
= memcached_instance_fetch(memc_ptr
, 0);
617 if (memc
.flags
.binary_protocol
)
619 rc
= binary_stats_fetch(memc_stat
, args
, args_length
, instance
, NULL
);
623 rc
= ascii_stats_fetch(memc_stat
, args
, args_length
, instance
, NULL
);
628 memcached_free(&memc
);
634 We make a copy of the keys since at some point in the not so distant future
635 we will add support for "found" keys.
637 char ** memcached_stat_get_keys(memcached_st
*ptr
,
639 memcached_return_t
*error
)
646 char **list
= static_cast<char **>(libmemcached_malloc(ptr
, sizeof(memcached_stat_keys
)));
649 *error
= memcached_set_error(*ptr
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
653 memcpy(list
, memcached_stat_keys
, sizeof(memcached_stat_keys
));
655 *error
= MEMCACHED_SUCCESS
;
660 void memcached_stat_free(const memcached_st
*, memcached_stat_st
*memc_stat
)
662 WATCHPOINT_ASSERT(memc_stat
); // Be polite, but when debugging catch this as an error
663 if (memc_stat
== NULL
)
670 libmemcached_free(memc_stat
->root
, memc_stat
);
674 libmemcached_free(NULL
, memc_stat
);
677 static memcached_return_t
call_stat_fn(memcached_st
*ptr
,
678 org::libmemcached::Instance
* instance
,
681 memcached_return_t rc
;
682 local_context
*check
= (struct local_context
*)context
;
684 if (memcached_is_binary(ptr
))
686 rc
= binary_stats_fetch(NULL
, check
->args
, check
->args_length
, instance
, check
);
690 rc
= ascii_stats_fetch(NULL
, check
->args
, check
->args_length
, instance
, check
);
696 memcached_return_t
memcached_stat_execute(memcached_st
*memc
, const char *args
, memcached_stat_fn func
, void *context
)
698 memcached_version(memc
);
700 local_context
check(func
, context
, args
, args
? strlen(args
) : 0);
702 return memcached_server_execute(memc
, call_stat_fn
, (void *)&check
);