X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.c;h=3b28515b2e6fe31d74493560595b9f5075600fc4;hb=9a00fe7032d5b9521004198479a4656f77bd4e3c;hp=516cd2c460c62ed4bd9e8602f4514499e347e7c0;hpb=ce11ec5eadbc51ff26aa6b64f52cf36e6b703f46;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.c b/libmemcached/server.c index 516cd2c4..3b28515b 100644 --- a/libmemcached/server.c +++ b/libmemcached/server.c @@ -19,6 +19,7 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r uint32_t weight, memcached_connection_t type) { self->options.sockaddr_inited= false; + self->options.is_shutting_down= false; self->number_of_hosts= 0; self->cursor_active= 0; self->port= port; @@ -53,14 +54,14 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r if (hostname == NULL) self->hostname[0]= 0; else - strncpy(self->hostname, hostname, MEMCACHED_MAX_HOST_LENGTH - 1); + strncpy(self->hostname, hostname, NI_MAXHOST - 1); } static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc) { if (self == NULL) { - self= (memcached_server_st *)memc->call_malloc(memc, sizeof(memcached_server_st)); + self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st)); if (! self) return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */ @@ -77,7 +78,8 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc return self; } -memcached_server_st *memcached_server_create_with(const memcached_st *memc, memcached_server_st *self, +memcached_server_st *memcached_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) { @@ -100,7 +102,7 @@ memcached_server_st *memcached_server_create_with(const memcached_st *memc, memc void memcached_server_free(memcached_server_st *self) { - memcached_quit_server(self, 0); + memcached_quit_server(self, false); if (self->cached_server_error) free(self->cached_server_error); @@ -110,7 +112,7 @@ void memcached_server_free(memcached_server_st *self) if (memcached_is_allocated(self)) { - self->root->call_free(self->root, self); + libmemcached_free(self->root, self); } else { @@ -143,24 +145,21 @@ memcached_server_st *memcached_server_clone(memcached_server_st *destination, } -memcached_return_t memcached_server_cursor(memcached_st *ptr, - memcached_server_fn *callback, +memcached_return_t memcached_server_cursor(const memcached_st *ptr, + const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks) { - uint32_t y; - - for (y= 0; y < memcached_server_count(ptr); y++) + for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - uint32_t x; memcached_server_instance_st *instance= - memcached_server_instance_fetch(ptr, y); + memcached_server_instance_by_position(ptr, x); - for (x= 0; x < number_of_callbacks; x++) + for (uint32_t y= 0; y < number_of_callbacks; y++) { unsigned int iferror; - iferror= (*callback[x])(ptr, instance, context); + iferror= (*callback[y])(ptr, instance, context); if (iferror) continue; @@ -170,7 +169,10 @@ memcached_return_t memcached_server_cursor(memcached_st *ptr, return MEMCACHED_SUCCESS; } -memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error) +memcached_server_instance_st *memcached_server_by_key(const memcached_st *ptr, + const char *key, + size_t key_length, + memcached_return_t *error) { uint32_t server_key; memcached_server_instance_st *instance; @@ -193,37 +195,116 @@ memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key } server_key= memcached_generate_hash(ptr, key, key_length); - instance= memcached_server_instance_fetch(ptr, server_key); + instance= memcached_server_instance_by_position(ptr, server_key); - return memcached_server_clone(NULL, instance); + return instance; } -const char *memcached_server_error(memcached_server_st *ptr) -{ - return ptr - ? ptr->cached_server_error - : NULL; -} - void memcached_server_error_reset(memcached_server_st *ptr) { ptr->cached_server_error[0]= 0; } -memcached_server_st *memcached_server_get_last_disconnect(memcached_st *ptr) +memcached_server_instance_st *memcached_server_get_last_disconnect(const memcached_st *ptr) { return ptr->last_disconnected_server; } -uint32_t memcached_server_list_count(memcached_server_st *ptr) +inline uint32_t memcached_server_list_count(const memcached_server_st *self) { - return (ptr == NULL) + return (self == NULL) ? 0 - : memcached_servers_count(ptr); + : self->number_of_hosts; } -void memcached_server_list_free(memcached_server_st *ptr) +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) +{ + 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); + + for (uint32_t x= 0; x < memcached_server_count(root); x++) + { + if (strncmp(list[x].hostname, self->hostname, NI_MAXHOST) != 0 || list[x].port != self->port) + { + 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++; + } + } + root->number_of_hosts= host_index; + + run_distribution(root); + + return MEMCACHED_SUCCESS; +} + + +inline uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) { - server_list_free(NULL, ptr); + return servers->number_of_hosts= count; } + +inline 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) +{ + return self->hostname; +} + +inline 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) +{ + return self->cursor_active; +} + +const char *memcached_server_error(memcached_server_instance_st *ptr) +{ + return ptr + ? ptr->cached_server_error + : NULL; +} +