X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Ferror.cc;h=38c568c91cdf48dd4b51088169646e6bfa44b2ed;hb=674c7578fa870c3b57e81e765c355ce98434b310;hp=70f5d22713cc95faf2bbb1abf1c83a3fd36ce653;hpb=ca4acb0672e11e89af59ce588ea9c441c20b4e7a;p=m6w6%2Flibmemcached diff --git a/libmemcached/error.cc b/libmemcached/error.cc index 70f5d227..38c568c9 100644 --- a/libmemcached/error.cc +++ b/libmemcached/error.cc @@ -36,6 +36,7 @@ */ #include +#include #define MAX_ERROR_LENGTH 2048 struct memcached_error_t @@ -49,28 +50,35 @@ struct memcached_error_t char message[MAX_ERROR_LENGTH]; }; -static void _set(memcached_server_st& server, memcached_st& memc) +static void _set(org::libmemcached::Instance& server, memcached_st& memc) { - if (server.error_messages && server.error_messages->query_id != server.root->query_id) + if (server.error_messages and server.error_messages->query_id != server.root->query_id) { memcached_error_free(server); } if (memc.error_messages == NULL) + { return; + } - memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t)); - if (not error) // Bad business if this happens + memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t); + if (error == NULL) // Bad business if this happens + { return; + } memcpy(error, memc.error_messages, sizeof(memcached_error_t)); error->next= server.error_messages; server.error_messages= error; } +#if 0 +static int error_log_fd= -1; +#endif + static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t &rc, const char *at, int local_errno= 0) { - (void)at; if (memc.error_messages && memc.error_messages->query_id != memc.query_id) { memcached_error_free(memc); @@ -108,9 +116,11 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t rc= MEMCACHED_CONNECTION_FAILURE; } - memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t)); - if (not error) // Bad business if this happens + memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t); + if (error == NULL) // Bad business if this happens + { return; + } error->root= &memc; error->query_id= memc.query_id; @@ -135,32 +145,56 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t if (str and str->size and local_errno) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s(%s), %.*s -> %s", + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s", + long(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, "%s(%s) -> %s", + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s", + long(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, "(%lu) %.*s -> %s", + long(error->root), + int(str->size), str->c_str, at); + } else if (str and str->size) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s, %.*s -> %s", + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s", + long(error->root), memcached_strerror(&memc, rc), int(str->size), str->c_str, at); } else { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s -> %s", + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s", + long(error->root), memcached_strerror(&memc, rc), at); } 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) + { + perror("open"); + error_log_fd= -1; + } + } + ::write(error_log_fd, error->message, error->size); + ::write(error_log_fd, "\n", 1); +#endif } memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, const char *str, size_t length) @@ -170,10 +204,11 @@ memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc return memcached_set_error(memc, rc, at, tmp); } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_error(org::libmemcached::Instance& 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 memcached_server_st"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance"); + memcached_string_t tmp= { str, length }; return memcached_set_error(self, rc, at, tmp); } @@ -181,60 +216,104 @@ memcached_return_t memcached_set_error(memcached_server_st& self, memcached_retu memcached_return_t memcached_set_error(memcached_st& 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_success(rc)) - return MEMCACHED_SUCCESS; + if (memcached_fatal(rc) == false) + { + return rc; + } _set(memc, &str, rc, at); return rc; } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_parser_error(memcached_st& memc, + const char *at, + const char *format, ...) +{ + va_list args; + + char buffer[BUFSIZ]; + va_start(args, format); + int length= vsnprintf(buffer, sizeof(buffer), format, args); + va_end(args); + + 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) +{ + size_t size= 0; + switch (self.type) + { + case MEMCACHED_CONNECTION_TCP: + case MEMCACHED_CONNECTION_UDP: + size+= snprintf(buffer, buffer_length, " host: %s:%d", + self.hostname, int(self.port())); + break; + + case MEMCACHED_CONNECTION_UNIX_SOCKET: + size+= snprintf(buffer, buffer_length, " socket: %s", + self.hostname); + break; + } + + return size; +} + +memcached_return_t memcached_set_error(org::libmemcached::Instance& 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 memcached_server_st"); - if (memcached_success(rc)) - return MEMCACHED_SUCCESS; + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + if (memcached_fatal(rc) == false) + { + return rc; + } char hostname_port_message[MAX_ERROR_LENGTH]; - int size; + char* hostname_port_message_ptr= hostname_port_message; + int size= 0; if (str.size) { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d", - memcached_string_printf(str), - self.hostname, int(self.port)); - } - else - { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size= snprintf(hostname_port_message_ptr, sizeof(hostname_port_message), "%.*s, ", + memcached_string_printf(str)); + hostname_port_message_ptr+= size; } - memcached_string_t error_host= { hostname_port_message, size }; + size+= append_host_to_string(self, hostname_port_message_ptr, sizeof(hostname_port_message) -size); + + memcached_string_t error_host= { hostname_port_message, size_t(size) }; - if (not self.root) + assert(self.root); + if (self.root == NULL) + { return rc; + } _set(*self.root, &error_host, rc, at); _set(self, (*self.root)); + assert(self.root->error_messages); + assert(self.error_messages); return rc; } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at) +memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at) { - 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 memcached_server_st"); - if (memcached_success(rc)) - return MEMCACHED_SUCCESS; + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + if (memcached_fatal(rc) == false) + { + return rc; + } char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")]; - int size= snprintf(hostname_port, sizeof(hostname_port), "host: %s:%d", self.hostname, int(self.port)); + size_t size= append_host_to_string(self, hostname_port, sizeof(hostname_port)); memcached_string_t error_host= { hostname_port, size}; - if (not self.root) + if (self.root == NULL) + { return rc; + } _set(*self.root, &error_host, rc, at); _set(self, *self.root); @@ -245,8 +324,10 @@ memcached_return_t memcached_set_error(memcached_server_st& self, memcached_retu memcached_return_t memcached_set_error(memcached_st& self, memcached_return_t rc, const char *at) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - if (memcached_success(rc)) - return MEMCACHED_SUCCESS; + if (memcached_fatal(rc) == false) + { + return rc; + } _set(self, NULL, rc, at); @@ -259,7 +340,7 @@ memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, cons return memcached_set_errno(self, local_errno, at, tmp); } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& 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); @@ -267,8 +348,10 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at) { - if (not local_errno) + if (local_errno == 0) + { return MEMCACHED_SUCCESS; + } memcached_return_t rc= MEMCACHED_ERRNO; _set(self, NULL, rc, at, local_errno); @@ -278,8 +361,10 @@ memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, cons memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str) { - if (not local_errno) + if (local_errno == 0) + { return MEMCACHED_SUCCESS; + } memcached_return_t rc= MEMCACHED_ERRNO; _set(memc, &str, rc, at, local_errno); @@ -287,30 +372,29 @@ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, cons return rc; } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str) { - if (not local_errno) + if (local_errno == 0) + { return MEMCACHED_SUCCESS; + } char hostname_port_message[MAX_ERROR_LENGTH]; - int size; + char* hostname_port_message_ptr= hostname_port_message; + size_t size= 0; if (str.size) { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d", - memcached_string_printf(str), - self.hostname, int(self.port)); - } - else - { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size= snprintf(hostname_port_message_ptr, sizeof(hostname_port_message), "%.*s, ", memcached_string_printf(str)); } + size+= append_host_to_string(self, hostname_port_message_ptr, sizeof(hostname_port_message) -size); memcached_string_t error_host= { hostname_port_message, size }; memcached_return_t rc= MEMCACHED_ERRNO; - if (not self.root) + if (self.root == NULL) + { return rc; + } _set(*self.root, &error_host, rc, at, local_errno); _set(self, (*self.root)); @@ -318,20 +402,23 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn return rc; } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at) { - if (not local_errno) + if (local_errno == 0) + { return MEMCACHED_SUCCESS; + } char hostname_port_message[MAX_ERROR_LENGTH]; - int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size_t size= append_host_to_string(self, hostname_port_message, sizeof(hostname_port_message)); memcached_string_t error_host= { hostname_port_message, size }; memcached_return_t rc= MEMCACHED_ERRNO; - if (not self.root) + if (self.root == NULL) + { return rc; + } _set(*self.root, &error_host, rc, at, local_errno); _set(self, (*self.root)); @@ -341,16 +428,18 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn static void _error_print(const memcached_error_t *error) { - if (not error) + if (error == NULL) + { return; + } - if (not error->size) + if (error->size == 0) { - fprintf(stderr, "%s\n", memcached_strerror(NULL, error->rc) ); + fprintf(stderr, "\t%s\n", memcached_strerror(NULL, error->rc) ); } else { - fprintf(stderr, "%s %s\n", memcached_strerror(NULL, error->rc), error->message); + fprintf(stderr, "\t%s %s\n", memcached_strerror(NULL, error->rc), error->message); } _error_print(error->next); @@ -358,27 +447,29 @@ static void _error_print(const memcached_error_t *error) void memcached_error_print(const memcached_st *self) { - if (not self) + if (self == NULL) + { return; + } _error_print(self->error_messages); + + for (uint32_t x= 0; x < memcached_server_count(self); x++) + { + org::libmemcached::Instance* instance= memcached_instance_by_position(self, x); + + _error_print(instance->error_messages); + } } static void _error_free(memcached_error_t *error) { - if (not error) - return; - - _error_free(error->next); - - if (error && error->root) + if (error) { + _error_free(error->next); + libmemcached_free(error->root, error); } - else if (error) - { - free(error); - } } void memcached_error_free(memcached_st& self) @@ -387,27 +478,38 @@ void memcached_error_free(memcached_st& self) self.error_messages= NULL; } +void memcached_error_free(org::libmemcached::Instance& self) +{ + _error_free(self.error_messages); + self.error_messages= NULL; +} + void memcached_error_free(memcached_server_st& self) { _error_free(self.error_messages); self.error_messages= NULL; } -const char *memcached_last_error_message(memcached_st *memc) +const char *memcached_last_error_message(const memcached_st *memc) { - if (not memc) + if (memc == NULL) + { return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS); + } - if (not memc->error_messages) + if (memc->error_messages == NULL) + { return memcached_strerror(memc, MEMCACHED_SUCCESS); + } - if (not memc->error_messages->size) + if (memc->error_messages->size == 0) + { return memcached_strerror(memc, memc->error_messages->rc); + } return memc->error_messages->message; } - bool memcached_has_current_error(memcached_st &memc) { if (memc.error_messages @@ -420,49 +522,70 @@ bool memcached_has_current_error(memcached_st &memc) return false; } -memcached_return_t memcached_last_error(memcached_st *memc) +bool memcached_has_current_error(org::libmemcached::Instance& server) +{ + return memcached_has_current_error(*(server.root)); +} + +memcached_return_t memcached_last_error(const memcached_st *memc) { - if (not memc) + if (memc == NULL) + { return MEMCACHED_INVALID_ARGUMENTS; + } - if (not memc->error_messages) + if (memc->error_messages == NULL) + { return MEMCACHED_SUCCESS; + } return memc->error_messages->rc; } -int memcached_last_error_errno(memcached_st *memc) +int memcached_last_error_errno(const memcached_st *memc) { - if (not memc) + if (memc == NULL) + { return 0; + } - if (not memc->error_messages) + if (memc->error_messages == NULL) + { return 0; + } return memc->error_messages->local_errno; } -const char *memcached_server_error(memcached_server_instance_st server) +const char *memcached_server_error(const memcached_server_instance_st server) { - if (not server) - return memcached_strerror(server->root, MEMCACHED_INVALID_ARGUMENTS); + if (server == NULL) + { + return NULL; + } - if (not server->error_messages) + if (server->error_messages == NULL) + { return memcached_strerror(server->root, MEMCACHED_SUCCESS); + } - if (not server->error_messages->size) + if (server->error_messages->size == 0) + { return memcached_strerror(server->root, server->error_messages->rc); + } return server->error_messages->message; } -memcached_error_t *memcached_error_copy(const memcached_server_st& server) +memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server) { - if (not server.error_messages) + if (server.error_messages == NULL) + { return NULL; + } - memcached_error_t *error= (memcached_error_t *)libmemcached_malloc(server.root, sizeof(memcached_error_t)); + memcached_error_t *error= libmemcached_xmalloc(server.root, memcached_error_t); memcpy(error, server.error_messages, sizeof(memcached_error_t)); error->next= NULL; @@ -471,10 +594,30 @@ memcached_error_t *memcached_error_copy(const memcached_server_st& server) memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr) { + if (ptr == NULL) + { + return MEMCACHED_INVALID_ARGUMENTS; + } + if (ptr and ptr->error_messages) { return ptr->error_messages->rc; } - return MEMCACHED_FAILURE; + return MEMCACHED_SUCCESS; +} + +memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance) +{ + if (instance == NULL) + { + return MEMCACHED_INVALID_ARGUMENTS; + } + + if (instance and instance->error_messages) + { + return instance->error_messages->rc; + } + + return MEMCACHED_SUCCESS; }