X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Ferror.cc;h=ced9d7a2ca1eb2e7a312928d5903939924c9a01a;hb=308d66cd759d7c1285550f5ca2a75cc32b74f146;hp=64aefa037d88e4f4a0df7655bd3d1246ca41c513;hpb=5086fce85b544731a8cf3c0d2c3dbb478ed90c43;p=awesomized%2Flibmemcached diff --git a/libmemcached/error.cc b/libmemcached/error.cc index 64aefa03..ced9d7a2 100644 --- a/libmemcached/error.cc +++ b/libmemcached/error.cc @@ -36,6 +36,9 @@ */ #include + +#include "libmemcached/assert.hpp" + #include #include #include @@ -52,7 +55,7 @@ struct memcached_error_t char message[MAX_ERROR_LENGTH]; }; -static void _set(org::libmemcached::Instance& server, Memcached& memc) +static void _set(memcached_instance_st& server, Memcached& memc) { if (server.error_messages and server.error_messages->query_id != server.root->query_id) { @@ -87,125 +90,146 @@ static void _set(Memcached& memc, memcached_string_t *str, memcached_return_t &r memcached_error_free(memc); } - // For memory allocation we use our error since it is a bit more specific - if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO) + if (memcached_fatal(rc) or rc == MEMCACHED_CLIENT_ERROR) { - rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE; - } + // For memory allocation we use our error since it is a bit more specific + if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO) + { + rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE; + } - if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE) - { - local_errno= ENOMEM; - } + if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE) + { + local_errno= ENOMEM; + } - if (rc == MEMCACHED_ERRNO and not local_errno) - { - local_errno= errno; - rc= MEMCACHED_ERRNO; - } + if (rc == MEMCACHED_ERRNO and not local_errno) + { + local_errno= errno; + rc= MEMCACHED_ERRNO; + } - if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN) - { - rc= MEMCACHED_CONNECTION_FAILURE; - } + if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN) + { + rc= MEMCACHED_CONNECTION_FAILURE; + } - if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET) - { - rc= MEMCACHED_CONNECTION_FAILURE; - } + if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET) + { + rc= MEMCACHED_CONNECTION_FAILURE; + } - if (local_errno == EINVAL) - { - rc= MEMCACHED_INVALID_ARGUMENTS; - } + if (local_errno == EINVAL) + { + rc= MEMCACHED_INVALID_ARGUMENTS; + } - if (local_errno == ECONNREFUSED) - { - rc= MEMCACHED_CONNECTION_FAILURE; - } + if (local_errno == ECONNREFUSED) + { + rc= MEMCACHED_CONNECTION_FAILURE; + } - memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t); - if (error == NULL) // Bad business if this happens - { - return; - } + if (rc == MEMCACHED_TIMEOUT) + { + } - error->root= &memc; - error->query_id= memc.query_id; - error->rc= rc; - error->local_errno= local_errno; + memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t); + if (error == NULL) // Bad business if this happens + { + assert_msg(error, "libmemcached_xmalloc() failed to allocate a memcached_error_t"); + return; + } - const char *errmsg_ptr; - char errmsg[MAX_ERROR_LENGTH]; - errmsg[0]= 0; - errmsg_ptr= errmsg; + error->root= &memc; + error->query_id= memc.query_id; + error->rc= rc; + error->local_errno= local_errno; + + // MEMCACHED_CLIENT_ERROR is a special case because it is an error coming from the server + if (rc == MEMCACHED_CLIENT_ERROR) + { + assert(str); + assert(str->size); + if (str and str->size) + { + assert(error->local_errno == 0); + error->local_errno= 0; + + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s", + error->root, + int(str->size), str->c_str); + } + } + else if (local_errno) + { + const char *errmsg_ptr; + char errmsg[MAX_ERROR_LENGTH]; + errmsg[0]= 0; + errmsg_ptr= errmsg; - if (local_errno) - { #if defined(STRERROR_R_CHAR_P) && STRERROR_R_CHAR_P - errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg)); + errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg)); #elif defined(HAVE_STRERROR_R) && HAVE_STRERROR_R - strerror_r(local_errno, errmsg, sizeof(errmsg)); - errmsg_ptr= errmsg; + strerror_r(local_errno, errmsg, sizeof(errmsg)); + errmsg_ptr= errmsg; #elif defined(HAVE_STRERROR) && HAVE_STRERROR - snprintf(errmsg, sizeof(errmsg), "%s", strerror(local_errno)); - errmsg_ptr= errmsg; + snprintf(errmsg, sizeof(errmsg), "%s", strerror(local_errno)); + errmsg_ptr= errmsg; #endif - } + if (str and str->size and local_errno) + { + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", + error->root, + memcached_strerror(&memc, rc), + errmsg_ptr, + memcached_string_printf(*str), at); + } + else + { + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", + error->root, + memcached_strerror(&memc, rc), + errmsg_ptr, + at); + } + } + else if (rc == MEMCACHED_PARSE_ERROR and str and str->size) + { + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", + error->root, + int(str->size), str->c_str, at); + } + else if (str and str->size) + { + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", + error->root, + memcached_strerror(&memc, rc), + int(str->size), str->c_str, at); + } + else + { + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", + error->root, + memcached_strerror(&memc, rc), at); + } - if (str and str->size and local_errno) - { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", - error->root, - memcached_strerror(&memc, rc), - errmsg_ptr, - memcached_string_printf(*str), at); - } - else if (local_errno) - { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", - error->root, - memcached_strerror(&memc, rc), - errmsg_ptr, - at); - } - else if (rc == MEMCACHED_PARSE_ERROR and str and str->size) - { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", - error->root, - int(str->size), str->c_str, at); - } - else if (str and str->size) - { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", - error->root, - memcached_strerror(&memc, rc), - int(str->size), str->c_str, at); - } - else - { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", - error->root, - memcached_strerror(&memc, rc), at); - } - - error->next= memc.error_messages; - memc.error_messages= error; - + error->next= memc.error_messages; + memc.error_messages= error; #if 0 - if (error_log_fd == -1) - { -// unlink("/tmp/libmemcachd.log"); - if ((error_log_fd= open("/tmp/libmemcachd.log", O_CREAT | O_WRONLY | O_APPEND, 0644)) < 0) + if (error_log_fd == -1) { - perror("open"); - error_log_fd= -1; + // unlink("/tmp/libmemcachd.log"); + if ((error_log_fd= open("/tmp/libmemcachd.log", O_CREAT | O_WRONLY | O_APPEND, 0644)) < 0) + { + perror("open"); + error_log_fd= -1; + } } - } - ::write(error_log_fd, error->message, error->size); - ::write(error_log_fd, "\n", 1); + ::write(error_log_fd, error->message, error->size); + ::write(error_log_fd, "\n", 1); #endif + } } memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, const char *str, size_t length) @@ -215,7 +239,7 @@ memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, c return memcached_set_error(memc, rc, at, tmp); } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance"); @@ -231,13 +255,11 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, memcached_string_t& str) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - if (memcached_fatal(rc) == false) + if (memcached_fatal(rc)) { - return rc; + _set(memc, &str, rc, at); } - _set(memc, &str, rc, at); - return rc; } @@ -255,7 +277,7 @@ memcached_return_t memcached_set_parser_error(Memcached& memc, return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length); } -static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length) +static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length) { size_t size= 0; switch (self.type) @@ -275,10 +297,10 @@ static inline size_t append_host_to_string(org::libmemcached::Instance& self, ch return size; } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st"); if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR) { return rc; @@ -299,23 +321,21 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac memcached_string_t error_host= { hostname_port_message, size_t(size) }; assert_msg(self.root, "Programmer error, root was not set on instance"); - if (self.root == NULL) + if (self.root) { - return rc; + _set(*self.root, &error_host, rc, at); + _set(self, (*self.root)); + assert(self.error_messages); + assert(self.root->error_messages); + assert(self.error_messages->rc == self.root->error_messages->rc); } - _set(*self.root, &error_host, rc, at); - _set(self, (*self.root)); - assert(self.root->error_messages); - assert(self.error_messages); - assert(self.error_messages->rc == self.root->error_messages->rc); - return rc; } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at) { - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st"); if (memcached_fatal(rc) == false) { return rc; @@ -326,14 +346,12 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac memcached_string_t error_host= { hostname_port, size}; - if (self.root == NULL) + if (self.root) { - return rc; + _set(*self.root, &error_host, rc, at); + _set(self, *self.root); } - _set(*self.root, &error_host, rc, at); - _set(self, *self.root); - return rc; } @@ -356,7 +374,7 @@ memcached_return_t memcached_set_errno(Memcached& self, int local_errno, const c return memcached_set_errno(self, local_errno, at, tmp); } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length) { memcached_string_t tmp= { str, length }; return memcached_set_errno(self, local_errno, at, tmp); @@ -388,7 +406,7 @@ memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const c return rc; } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str) { if (local_errno == 0) { @@ -427,7 +445,7 @@ memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int lo return rc; } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at) { if (local_errno == 0) { @@ -482,7 +500,7 @@ void memcached_error_print(const Memcached *shell) for (uint32_t x= 0; x < memcached_server_count(self); x++) { - org::libmemcached::Instance* instance= memcached_instance_by_position(self, x); + memcached_instance_st* instance= memcached_instance_by_position(self, x); _error_print(instance->error_messages); } @@ -504,7 +522,7 @@ void memcached_error_free(Memcached& self) self.error_messages= NULL; } -void memcached_error_free(org::libmemcached::Instance& self) +void memcached_error_free(memcached_instance_st& self) { _error_free(self.error_messages); self.error_messages= NULL; @@ -528,7 +546,7 @@ const char *memcached_last_error_message(const memcached_st *shell) { if (memc->error_messages) { - if (memc->error_messages->size == 0) + if (memc->error_messages->size and memc->error_messages->message[0]) { return memc->error_messages->message; } @@ -554,7 +572,7 @@ bool memcached_has_current_error(Memcached &memc) return false; } -bool memcached_has_current_error(org::libmemcached::Instance& server) +bool memcached_has_current_error(memcached_instance_st& server) { return memcached_has_current_error(*(server.root)); } @@ -591,7 +609,7 @@ int memcached_last_error_errno(const memcached_st *shell) return memc->error_messages->local_errno; } -const char *memcached_server_error(const memcached_server_instance_st server) +const char *memcached_server_error(const memcached_instance_st * server) { if (server == NULL) { @@ -612,7 +630,7 @@ const char *memcached_server_error(const memcached_server_instance_st server) } -memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server) +memcached_error_t *memcached_error_copy(const memcached_instance_st& server) { if (server.error_messages == NULL) { @@ -626,7 +644,7 @@ memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& serve return error; } -memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr) +memcached_return_t memcached_server_error_return(const memcached_instance_st * ptr) { if (ptr == NULL) { @@ -641,7 +659,7 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt return MEMCACHED_SUCCESS; } -memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance) +memcached_return_t memcached_instance_error_return(memcached_instance_st* instance) { if (instance == NULL) {