#include <libmemcached/common.h>
-static memcached_return_t ascii_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
+static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
{
- memcached_return_t rc= MEMCACHED_SUCCESS;
-
- for (uint32_t server_key= 0; server_key < memcached_server_count(ptr); server_key++)
+ /* MAX_NUMBER_OF_SLAB_CLASSES is defined to 200 in Memcached 1.4.10 */
+ for (uint32_t x= 0; x < 200; x++)
{
- memcached_server_write_instance_st instance;
- instance= memcached_server_instance_fetch(ptr, server_key);
-
- /* 256 I BELIEVE is the upper limit of slabs */
- for (uint32_t x= 0; x < 256; x++)
+ char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+ int buffer_length= snprintf(buffer, sizeof(buffer), "%u", x);
+ if (size_t(buffer_length) >= sizeof(buffer) or buffer_length < 0)
{
- char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
- int buffer_length= snprintf(buffer, sizeof(buffer), "%u", x);
- if (buffer_length >= MEMCACHED_DEFAULT_COMMAND_SIZE or buffer_length < 0)
- {
- return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
- memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)"));
- }
+ return memcached_set_error(*memc, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
+ memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)"));
+ }
- struct libmemcached_io_vector_st vector[]=
- {
- { memcached_literal_param("stats cachedump ") },
- { buffer, buffer_length },
- { memcached_literal_param(" 0 0\r\n") }
- };
+ // @NOTE the hard coded zero means "no limit"
+ libmemcached_io_vector_st vector[]=
+ {
+ { memcached_literal_param("stats cachedump ") },
+ { buffer, size_t(buffer_length) },
+ { memcached_literal_param(" 0\r\n") }
+ };
- rc= memcached_vdo(instance, vector, 3, true);
+ // Send message to all servers
+ for (uint32_t server_key= 0; server_key < memcached_server_count(memc); server_key++)
+ {
+ memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
- if (rc != MEMCACHED_SUCCESS)
+ memcached_return_t vdo_rc;
+ if (memcached_success((vdo_rc= memcached_vdo(instance, vector, 3, true))))
{
- goto error;
+ // We have sent the message to the server successfully
}
-
- while (1)
+ else
{
- uint32_t callback_counter;
- rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+ return vdo_rc;
+ }
+ }
- if (rc == MEMCACHED_ITEM)
- {
- char *string_ptr, *end_ptr;
+ // Collect the returned items
+ memcached_instance_st* instance;
+ memcached_return_t read_ret= MEMCACHED_SUCCESS;
+ while ((instance= memcached_io_get_readable_server(memc, read_ret)))
+ {
+ memcached_return_t response_rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+ if (response_rc == MEMCACHED_ITEM)
+ {
+ char *string_ptr, *end_ptr;
- string_ptr= buffer;
- string_ptr+= 5; /* Move past ITEM */
+ string_ptr= buffer;
+ string_ptr+= 5; /* Move past ITEM */
- for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++) {} ;
+ for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++) {} ;
- char *key= string_ptr;
- key[(size_t)(end_ptr-string_ptr)]= 0;
+ char *key= string_ptr;
+ key[(size_t)(end_ptr-string_ptr)]= 0;
- for (callback_counter= 0; callback_counter < number_of_callbacks; callback_counter++)
+ for (uint32_t callback_counter= 0; callback_counter < number_of_callbacks; callback_counter++)
+ {
+ memcached_return_t callback_rc= (*callback[callback_counter])(memc, key, (size_t)(end_ptr-string_ptr), context);
+ if (callback_rc != MEMCACHED_SUCCESS)
{
- rc= (*callback[callback_counter])(ptr, key, (size_t)(end_ptr-string_ptr), context);
- if (rc != MEMCACHED_SUCCESS)
- {
- break;
- }
+ // @todo build up a message for the error from the value
+ memcached_set_error(*instance, callback_rc, MEMCACHED_AT);
+ break;
}
}
- else if (rc == MEMCACHED_END)
- {
- break;
- }
- else if (rc == MEMCACHED_SERVER_ERROR or rc == MEMCACHED_CLIENT_ERROR)
- {
- /* If we try to request stats cachedump for a slab class that is too big
- * the server will return an incorrect error message:
- * "MEMCACHED_SERVER_ERROR failed to allocate memory"
- * This isn't really a fatal error, so let's just skip it. I want to
- * fix the return value from the memcached server to a CLIENT_ERROR,
- * so let's add support for that as well right now.
+ }
+ else if (response_rc == MEMCACHED_END)
+ {
+ // All items have been returned
+ }
+ else if (response_rc == MEMCACHED_SERVER_ERROR)
+ {
+ /* If we try to request stats cachedump for a slab class that is too big
+ * the server will return an incorrect error message:
+ * "MEMCACHED_SERVER_ERROR failed to allocate memory"
+ * This isn't really a fatal error, so let's just skip it. I want to
+ * fix the return value from the memcached server to a CLIENT_ERROR,
+ * so let's add support for that as well right now.
+ */
+ assert(response_rc == MEMCACHED_SUCCESS); // Just fail
+ return response_rc;
+ }
+ else if (response_rc == MEMCACHED_CLIENT_ERROR)
+ {
+ /* The maximum number of slabs has changed in the past (currently 1<<6-1),
+ * so ignore any client errors complaining about an illegal slab id.
*/
- rc= MEMCACHED_END;
- break;
- }
- else
- {
- goto error;
+ if (0 == strncmp(buffer, "CLIENT_ERROR Illegal slab id", sizeof("CLIENT_ERROR Illegal slab id") - 1)) {
+ memcached_error_free(*instance);
+ memcached_error_free(*memc);
+ } else {
+ return response_rc;
}
}
+ else
+ {
+ // IO error of some sort must have occurred
+ return response_rc;
+ }
}
}
-error:
- if (rc == MEMCACHED_END)
- {
- return MEMCACHED_SUCCESS;
- }
- else
- {
- return rc;
- }
+ return memcached_has_current_error(*memc) ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS;
}
-memcached_return_t memcached_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
+memcached_return_t memcached_dump(memcached_st *shell, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
{
+ Memcached* ptr= memcached2Memcached(shell);
memcached_return_t rc;
- if ((rc= initialize_query(ptr)) != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc= initialize_query(ptr, true)))
{
return rc;
}
No support for Binary protocol yet
@todo Fix this so that we just flush, switch to ascii, and then go back to binary.
*/
- if (ptr->flags.binary_protocol)
+ if (memcached_is_binary(ptr))
{
- return MEMCACHED_FAILURE;
+ return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, memcached_literal_param("Binary protocol is not supported for memcached_dump()"));
}
return ascii_dump(ptr, callback, context, number_of_callbacks);