X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.cc;h=9345da0b3a28eb1957e7bc19d33473ea95d94e4b;hb=b5495838fb245aa1068a1198ed549b98a9c3e666;hp=f5fe62e19bf3729fe867c1542c29bc286196ee45;hpb=9cd57ce737375540f6c3b5e2e3684160e5c4bfce;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.cc b/libmemcached/server.cc index f5fe62e1..9345da0b 100644 --- a/libmemcached/server.cc +++ b/libmemcached/server.cc @@ -39,10 +39,10 @@ This is a partial implementation for fetching/creating memcached_server_st objects. */ #include -#include static inline void _server_init(memcached_server_st *self, memcached_st *root, - const char *hostname, in_port_t port, + const memcached_string_t& hostname, + in_port_t port, uint32_t weight, memcached_connection_t type) { self->options.is_shutting_down= false; @@ -50,12 +50,16 @@ static inline void _server_init(memcached_server_st *self, memcached_st *root, self->number_of_hosts= 0; self->cursor_active= 0; self->port= port; - self->fd= -1; + self->fd= INVALID_SOCKET; self->io_bytes_sent= 0; + self->request_id= 0; self->server_failure_counter= 0; + self->server_failure_counter_query_id= 0; self->weight= weight ? weight : 1; // 1 is the default weight value - WATCHPOINT_SET(self->io_wait_count.read= 0); - WATCHPOINT_SET(self->io_wait_count.write= 0); + self->io_wait_count.read= 0; + self->io_wait_count.write= 0; + self->io_wait_count.timeouts= 0; + self->io_wait_count._bytes_read= 0; self->major_version= UINT8_MAX; self->micro_version= UINT8_MAX; self->minor_version= UINT8_MAX; @@ -69,36 +73,32 @@ static inline void _server_init(memcached_server_st *self, memcached_st *root, self->address_info_next= NULL; self->state= MEMCACHED_SERVER_STATE_NEW; + self->next_retry= 0; + self->root= root; if (root) { - self->next_retry= root->retry_timeout; + self->version= ++root->server_info.version; } else { - self->next_retry= 0; + self->version= UINT_MAX; } - - self->root= root; self->limit_maxbytes= 0; - if (hostname) - { - strncpy(self->hostname, hostname, NI_MAXHOST - 1); - } - else - { - self->hostname[0]= 0; - } + memcpy(self->hostname, hostname.c_str, hostname.size); + self->hostname[hostname.size]= 0; } static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc) { - if (not self) + if (self == NULL) { - self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st)); + self= libmemcached_xmalloc(memc, struct memcached_server_st); - if (not self) + if (self == NULL) + { return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */ + } self->options.is_allocated= true; } @@ -112,25 +112,39 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc return self; } -memcached_server_st *__server_create_with(const memcached_st *memc, +memcached_server_st *__server_create_with(memcached_st *memc, memcached_server_write_instance_st self, - const char *hostname, in_port_t port, - uint32_t weight, memcached_connection_t type) + const memcached_string_t& hostname, + const in_port_t port, + uint32_t weight, + const memcached_connection_t type) { + if (memcached_is_valid_servername(hostname) == false) + { + memcached_set_error(*memc, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Invalid hostname provided")); + return NULL; + } + self= _server_create(self, memc); - if (not self) + if (self == NULL) + { return NULL; + } _server_init(self, const_cast(memc), hostname, port, weight, type); - - if (type == MEMCACHED_CONNECTION_UDP) - { + if (memc and memcached_is_udp(memc)) + { self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; memcached_io_init_udp_header(self, 0); } + if (memc) + { + memcached_connect_try(self); + } + return self; } @@ -141,6 +155,8 @@ void __server_free(memcached_server_st *self) if (self->address_info) { freeaddrinfo(self->address_info); + self->address_info= NULL; + self->address_info_next= NULL; } memcached_error_free(*self); @@ -157,8 +173,10 @@ void __server_free(memcached_server_st *self) void memcached_server_free(memcached_server_st *self) { - if (not self) + if (self == NULL) + { return; + } if (memcached_server_list_count(self)) { @@ -173,23 +191,19 @@ void memcached_server_free(memcached_server_st *self) If we do not have a valid object to clone from, we toss an error. */ memcached_server_st *memcached_server_clone(memcached_server_st *destination, - const memcached_server_st *source) + memcached_server_st *source) { /* We just do a normal create if source is missing */ - if (not source) + if (source == NULL) + { return NULL; + } + memcached_string_t hostname= { memcached_string_make_from_cstr(source->hostname) }; destination= __server_create_with(source->root, destination, - source->hostname, source->port, source->weight, + hostname, + source->port, source->weight, source->type); - if (not destination) - { - if (source->error_messages) - { - destination->error_messages= memcached_error_copy(*source); - } - } - return destination; } @@ -230,37 +244,45 @@ memcached_return_t memcached_server_execute(memcached_st *ptr, memcached_server_execute_fn callback, void *context) { + if (callback == NULL) + { + return MEMCACHED_INVALID_ARGUMENTS; + } + + bool some_errors= false;; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x); - unsigned int iferror= (*callback)(ptr, instance, context); - - if (iferror) - continue; + memcached_return_t rc= (*callback)(ptr, instance, context); + if (rc == MEMCACHED_INVALID_ARGUMENTS) + { + return rc; + } + else if (memcached_fatal(rc)) + { + some_errors= true; + } } + (void)some_errors; return MEMCACHED_SUCCESS; } -memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr, +memcached_server_instance_st memcached_server_by_key(memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error) { - memcached_return_t rc; memcached_return_t unused; - if (not error) - error= &unused; - - if (memcached_failed(rc= initialize_const_query(ptr))) { - *error= rc; - return NULL; + error= &unused; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + + memcached_return_t rc; + if (memcached_failed(rc= initialize_const_query(ptr))) { *error= rc; return NULL; @@ -268,7 +290,7 @@ memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr, if (memcached_failed((memcached_key_test(*ptr, (const char **)&key, &key_length, 1)))) { - *error= MEMCACHED_BAD_KEY_PROVIDED; + *error= memcached_last_error(ptr); return NULL; } @@ -280,8 +302,10 @@ memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr, void memcached_server_error_reset(memcached_server_st *self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return; + } memcached_error_free(*self); } @@ -289,8 +313,10 @@ void memcached_server_error_reset(memcached_server_st *self) memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return 0; + } return self->last_disconnected_server; } @@ -298,8 +324,10 @@ memcached_server_instance_st memcached_server_get_last_disconnect(const memcache uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) { WATCHPOINT_ASSERT(servers); - if (not servers) + if (servers == NULL) + { return 0; + } return servers->number_of_hosts= count; } @@ -307,40 +335,44 @@ uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t coun uint32_t memcached_server_count(const memcached_st *self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) return 0; return self->number_of_hosts; } -const char *memcached_server_name(memcached_server_instance_st self) +const char *memcached_server_name(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) return NULL; return self->hostname; } -in_port_t memcached_server_port(memcached_server_instance_st self) +in_port_t memcached_server_port(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return 0; + } return self->port; } -uint32_t memcached_server_response_count(memcached_server_instance_st self) +uint32_t memcached_server_response_count(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return 0; + } return self->cursor_active; } -const char *memcached_server_type(memcached_server_instance_st ptr) +const char *memcached_server_type(const memcached_server_instance_st ptr) { if (ptr) { @@ -354,10 +386,6 @@ const char *memcached_server_type(memcached_server_instance_st ptr) case MEMCACHED_CONNECTION_UNIX_SOCKET: return "SOCKET"; - - case MEMCACHED_CONNECTION_MAX: - case MEMCACHED_CONNECTION_UNKNOWN: - break; } }