X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.cc;h=f68e1f6b81bf3ad734fc8535540cb5d869c3319a;hb=e2688497603c56929e6dd2b4e6139dd85edcb0e0;hp=955e1b30a248e414752663320cc00368a5cb7e16;hpb=c87f1a554cce74ac1ba3d4e7e9c2a1d2904e4766;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.cc b/libmemcached/server.cc index 955e1b30..f68e1f6b 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,55 +50,48 @@ 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->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; self->type= type; self->error_messages= NULL; - self->read_ptr= self->read_buffer; - self->read_buffer_length= 0; - self->read_data_length= 0; - self->write_buffer_offset= 0; - self->address_info= NULL; - 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,37 +105,33 @@ 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_write_instance_st self, - const char *hostname, in_port_t port, - uint32_t weight, memcached_connection_t type) +memcached_server_st *__server_create_with(memcached_st *memc, + memcached_server_st* allocated_instance, + const memcached_string_t& hostname, + const in_port_t port, + uint32_t weight, + const memcached_connection_t type) { - self= _server_create(self, memc); - - if (not self) + if (memcached_is_valid_servername(hostname) == false) + { + memcached_set_error(*memc, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Invalid hostname provided")); return NULL; + } - _server_init(self, const_cast(memc), hostname, port, weight, type); - + allocated_instance= _server_create(allocated_instance, memc); - if (type == MEMCACHED_CONNECTION_UDP) + if (allocated_instance == NULL) { - self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; - memcached_io_init_udp_header(self, 0); + return NULL; } - return self; + _server_init(allocated_instance, const_cast(memc), hostname, port, weight, type); + + return allocated_instance; } void __server_free(memcached_server_st *self) { - memcached_quit_server(self, false); - - if (self->address_info) - { - freeaddrinfo(self->address_info); - } - memcached_error_free(*self); if (memcached_is_allocated(self)) @@ -157,8 +146,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)) { @@ -169,137 +160,24 @@ void memcached_server_free(memcached_server_st *self) __server_free(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) -{ - /* We just do a normal create if source is missing */ - if (not source) - return NULL; - - destination= __server_create_with(source->root, destination, - source->hostname, source->port, source->weight, - source->type); - if (not destination) - { - if (source->error_messages) - { - destination->error_messages= memcached_error_copy(*source); - } - } - - return destination; - -} - -memcached_return_t memcached_server_cursor(const memcached_st *ptr, - const memcached_server_fn *callback, - void *context, - uint32_t number_of_callbacks) -{ - memcached_return_t rc; - if (memcached_failed(rc= initialize_const_query(ptr))) - { - return rc; - } - - size_t errors= 0; - for (uint32_t x= 0; x < memcached_server_count(ptr); x++) - { - memcached_server_instance_st instance= - memcached_server_instance_by_position(ptr, x); - - for (uint32_t y= 0; y < number_of_callbacks; y++) - { - memcached_return_t ret= (*callback[y])(ptr, instance, context); - - if (memcached_failed(ret)) - { - errors++; - continue; - } - } - } - - return errors ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS; -} - -memcached_return_t memcached_server_execute(memcached_st *ptr, - memcached_server_execute_fn callback, - void *context) -{ - 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; - } - - return MEMCACHED_SUCCESS; -} - -memcached_server_instance_st memcached_server_by_key(const 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; - } - - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) - { - *error= rc; - return NULL; - } - - if (memcached_failed((memcached_key_test(*ptr, (const char **)&key, &key_length, 1)))) - { - *error= MEMCACHED_BAD_KEY_PROVIDED; - return NULL; - } - - uint32_t server_key= memcached_generate_hash(ptr, key, key_length); - return memcached_server_instance_by_position(ptr, server_key); - -} - void memcached_server_error_reset(memcached_server_st *self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return; + } memcached_error_free(*self); } -memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *self) -{ - WATCHPOINT_ASSERT(self); - if (not self) - return 0; - - return self->last_disconnected_server; -} - 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,7 +185,7 @@ 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; @@ -316,7 +194,7 @@ uint32_t memcached_server_count(const memcached_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; @@ -325,19 +203,23 @@ const char *memcached_server_name(const 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; + return self->port(); } 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; + return self->cursor_active_; } const char *memcached_server_type(const memcached_server_instance_st ptr) @@ -354,12 +236,38 @@ const char *memcached_server_type(const memcached_server_instance_st ptr) case MEMCACHED_CONNECTION_UNIX_SOCKET: return "SOCKET"; - - case MEMCACHED_CONNECTION_MAX: - case MEMCACHED_CONNECTION_UNKNOWN: - break; } } return "UNKNOWN"; } + +uint8_t memcached_server_major_version(const memcached_server_instance_st instance) +{ + if (instance) + { + return instance->major_version; + } + + return UINT8_MAX; +} + +uint8_t memcached_server_minor_version(const memcached_server_instance_st instance) +{ + if (instance) + { + return instance->minor_version; + } + + return UINT8_MAX; +} + +uint8_t memcached_server_micro_version(const memcached_server_instance_st instance) +{ + if (instance) + { + return instance->micro_version; + } + + return UINT8_MAX; +}