X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.cc;h=f68e1f6b81bf3ad734fc8535540cb5d869c3319a;hb=e2688497603c56929e6dd2b4e6139dd85edcb0e0;hp=e1b91b94ceab24c229ecc6b8a5c4e473b902652d;hpb=de4a9c2f387cb27a298146ab6eae50bd1f35ce56;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.cc b/libmemcached/server.cc index e1b91b94..f68e1f6b 100644 --- a/libmemcached/server.cc +++ b/libmemcached/server.cc @@ -50,24 +50,20 @@ 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; @@ -88,11 +84,11 @@ static inline void _server_init(memcached_server_st *self, memcached_st *root, 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 */ } @@ -110,7 +106,7 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc } memcached_server_st *__server_create_with(memcached_st *memc, - memcached_server_write_instance_st self, + memcached_server_st* allocated_instance, const memcached_string_t& hostname, const in_port_t port, uint32_t weight, @@ -122,41 +118,20 @@ memcached_server_st *__server_create_with(memcached_st *memc, return NULL; } - self= _server_create(self, memc); + allocated_instance= _server_create(allocated_instance, memc); - if (self == NULL) + if (allocated_instance == NULL) { return NULL; } - _server_init(self, const_cast(memc), hostname, port, weight, type); + _server_init(allocated_instance, const_cast(memc), hostname, port, weight, type); - - if (memc and memcached_is_udp(memc)) - { - self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; - memcached_io_init_udp_header(self, 0); - } - - if (memc) - { - set_hostinfo(self); - } - - return self; + return allocated_instance; } void __server_free(memcached_server_st *self) { - memcached_quit_server(self, false); - - if (self->address_info) - { - freeaddrinfo(self->address_info); - self->address_info= NULL; - self->address_info_next= NULL; - } - memcached_error_free(*self); if (memcached_is_allocated(self)) @@ -185,118 +160,10 @@ 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, - memcached_server_st *source) -{ - /* We just do a normal create if source is missing */ - if (source == NULL) - { - return NULL; - } - - memcached_string_t hostname= { memcached_string_make_from_cstr(source->hostname) }; - destination= __server_create_with(source->root, destination, - hostname, - source->port, source->weight, - source->type); - 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(memcached_st *ptr, - const char *key, - size_t key_length, - memcached_return_t *error) -{ - memcached_return_t unused; - if (not error) - { - error= &unused; - } - - - memcached_return_t rc; - 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; } @@ -304,20 +171,13 @@ void memcached_server_error_reset(memcached_server_st *self) 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; } @@ -325,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; @@ -334,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; @@ -343,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) @@ -377,3 +241,33 @@ const char *memcached_server_type(const memcached_server_instance_st ptr) 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; +}