X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.cc;h=b38120ad424c002b8568bb0a6bc4ff2f826f9322;hb=d9db3f534bc38ea22e83e5529ff93aea4150ab19;hp=f2f78211fe35beedb73ce138f64d4e950cf97677;hpb=015b6142ad6c3b496437d397416aacb776a42aed;p=awesomized%2Flibmemcached diff --git a/libmemcached/server.cc b/libmemcached/server.cc index f2f78211..b38120ad 100644 --- a/libmemcached/server.cc +++ b/libmemcached/server.cc @@ -40,7 +40,7 @@ */ #include -static inline void _server_init(memcached_server_st *self, memcached_st *root, +static inline void _server_init(memcached_server_st *self, Memcached *root, const memcached_string_t& hostname, in_port_t port, uint32_t weight, memcached_connection_t type) @@ -50,25 +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= 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 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; @@ -87,7 +82,7 @@ static inline void _server_init(memcached_server_st *self, memcached_st *root, self->hostname[hostname.size]= 0; } -static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc) +static memcached_server_st *_server_create(memcached_server_st *self, const Memcached *memc) { if (self == NULL) { @@ -110,8 +105,8 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc return self; } -memcached_server_st *__server_create_with(memcached_st *memc, - memcached_server_write_instance_st self, +memcached_server_st *__server_create_with(Memcached *memc, + memcached_server_st* allocated_instance, const memcached_string_t& hostname, const in_port_t port, uint32_t weight, @@ -123,40 +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); - - if (memc and memcached_is_udp(memc)) - { - self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; - memcached_io_init_udp_header(self, 0); - } + _server_init(allocated_instance, const_cast(memc), hostname, port, weight, type); - if (memc) - { - memcached_connect_try(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,6 @@ 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) -{ - 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); - - 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(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((memcached_key_test(*ptr, (const char **)&key, &key_length, 1)))) - { - *error= memcached_last_error(ptr); - 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); @@ -308,17 +171,6 @@ 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 (self == NULL) - { - return 0; - } - - return self->last_disconnected_server; -} - uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) { WATCHPOINT_ASSERT(servers); @@ -339,34 +191,40 @@ uint32_t memcached_server_count(const memcached_st *self) return self->number_of_hosts; } -const char *memcached_server_name(const memcached_server_instance_st self) +const char *memcached_server_name(const memcached_instance_st * self) { WATCHPOINT_ASSERT(self); - if (self == NULL) - return NULL; + if (self) + { + return self->_hostname; + } - return self->hostname; + return NULL; } -in_port_t memcached_server_port(const memcached_server_instance_st self) +in_port_t memcached_server_port(const memcached_instance_st * self) { WATCHPOINT_ASSERT(self); if (self == NULL) + { return 0; + } - return self->port; + return self->port(); } -uint32_t memcached_server_response_count(const memcached_server_instance_st self) +uint32_t memcached_server_response_count(const memcached_instance_st * self) { WATCHPOINT_ASSERT(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) +const char *memcached_server_type(const memcached_instance_st * ptr) { if (ptr) { @@ -385,3 +243,33 @@ const char *memcached_server_type(const memcached_server_instance_st ptr) return "UNKNOWN"; } + +uint8_t memcached_server_major_version(const memcached_instance_st * instance) +{ + if (instance) + { + return instance->major_version; + } + + return UINT8_MAX; +} + +uint8_t memcached_server_minor_version(const memcached_instance_st * instance) +{ + if (instance) + { + return instance->minor_version; + } + + return UINT8_MAX; +} + +uint8_t memcached_server_micro_version(const memcached_instance_st * instance) +{ + if (instance) + { + return instance->micro_version; + } + + return UINT8_MAX; +}