X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.c;h=b446d13155bc33456e151c3c92012044b884c253;hb=259ed7e68a0de0887e9aedbe0aa5fdd9404929f9;hp=ee9d857569075e4c4e9402f4eb652a882e8b807a;hpb=c29c787187baac1f403668a5dbf8ba481b9a8c8e;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.c b/libmemcached/server.c index ee9d8575..b446d131 100644 --- a/libmemcached/server.c +++ b/libmemcached/server.c @@ -12,14 +12,14 @@ /* This is a partial implementation for fetching/creating memcached_server_st objects. */ -#include "common.h" +#include static inline void _server_init(memcached_server_st *self, const memcached_st *root, const char *hostname, in_port_t port, uint32_t weight, memcached_connection_t type) { - self->options.sockaddr_inited= false; self->options.is_shutting_down= false; + self->options.is_dead= false; self->number_of_hosts= 0; self->cursor_active= 0; self->port= port; @@ -27,11 +27,12 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r self->fd= -1; self->io_bytes_sent= 0; self->server_failure_counter= 0; - self->weight= weight; - self->state.is_corked= false; - self->major_version= 0; - self->micro_version= 0; - self->minor_version= 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->major_version= UINT8_MAX; + self->micro_version= UINT8_MAX; + self->minor_version= UINT8_MAX; self->type= type; self->read_ptr= self->read_buffer; self->cached_server_error= NULL; @@ -39,6 +40,7 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r self->read_data_length= 0; self->write_buffer_offset= 0; self->address_info= NULL; + self->address_info_next= NULL; if (root) { @@ -49,12 +51,21 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r self->next_retry= 0; } + if (self->weight > 1 && root) + { + ((memcached_st *)root)->ketama.weighted= true; + } + self->root= root; self->limit_maxbytes= 0; if (hostname == NULL) + { self->hostname[0]= 0; + } else + { strncpy(self->hostname, hostname, NI_MAXHOST - 1); + } } static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc) @@ -112,7 +123,14 @@ void memcached_server_free(memcached_server_st *self) if (memcached_is_allocated(self)) { - libmemcached_free(self->root, self); + if (self->root) + { + libmemcached_free(self->root, self); + } + else + { + free(self); + } } else { @@ -169,6 +187,26 @@ memcached_return_t memcached_server_cursor(const memcached_st *ptr, return 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; + + 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, @@ -211,92 +249,52 @@ memcached_server_instance_st memcached_server_get_last_disconnect(const memcache return ptr->last_disconnected_server; } -inline uint32_t memcached_server_list_count(const memcached_server_st *self) -{ - return (self == NULL) - ? 0 - : self->number_of_hosts; -} - -void memcached_server_list_free(memcached_server_st *self) -{ - server_list_free(NULL, self); -} - -/** - @todo allow lists to query themselves even if they lack a root -*/ -memcached_return_t memcached_server_remove(memcached_server_st *self) +void memcached_server_list_free(memcached_server_list_st self) { - uint32_t host_index= 0; - memcached_st *root= (memcached_st *)self->root; - memcached_server_st *list; - - if (root == NULL) - return MEMCACHED_FAILURE; - - list= memcached_server_list(root); - - /* Until we devise a way to mark servers that are about to be harvested, we need to shutdown before doing the clone. */ - memcached_quit(root); + if (self == NULL) + return; - for (uint32_t x= 0; x < memcached_server_count(root); x++) + for (uint32_t x= 0; x < memcached_server_list_count(self); x++) { - if (strncmp(list[x].hostname, self->hostname, NI_MAXHOST) != 0 || list[x].port != self->port) + if (self[x].address_info) { - if (host_index != x) - { - memcached_server_st *check= - memcached_server_clone(list+host_index, list+x); - - if (! check) // Now we are in trouble, allocation didn't happen and we are midway through an operation. Bail! - { - return MEMCACHED_FAILURE; - } - memcached_server_free(list+x); - } - host_index++; + freeaddrinfo(self[x].address_info); + self[x].address_info= NULL; } } - root->number_of_hosts= host_index; - run_distribution(root); - - return MEMCACHED_SUCCESS; + const memcached_st *root= self->root; + if (root) + { + libmemcached_free(root, self); + } + else + { + free(self); + } } - -inline uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) +uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) { return servers->number_of_hosts= count; } -inline uint32_t memcached_server_count(const memcached_st *self) +uint32_t memcached_server_count(const memcached_st *self) { return self->number_of_hosts; } -inline const char *memcached_server_name(memcached_server_instance_st self) +const char *memcached_server_name(memcached_server_instance_st self) { return self->hostname; } -inline in_port_t memcached_server_port(memcached_server_instance_st self) +in_port_t memcached_server_port(memcached_server_instance_st self) { return self->port; } -inline memcached_server_st *memcached_server_list(memcached_st *self) -{ - return self->servers; -} - -inline void memcached_server_list_set(memcached_st *self, memcached_server_st *list) -{ - self->servers= list; -} - -inline uint32_t memcached_server_response_count(memcached_server_instance_st self) +uint32_t memcached_server_response_count(memcached_server_instance_st self) { return self->cursor_active; }