X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fhosts.c;h=4018a2581d7846865378e583b7b0eca997fadb8e;hb=6b46b12051fa265bbd9c2a17899a280c8bd82769;hp=a923ec71e8430bcf1698cd8099923cb14c9b57d5;hpb=bf4da83be9c867a2ecb10615297aa5dd5cb1d6ab;p=awesomized%2Flibmemcached diff --git a/libmemcached/hosts.c b/libmemcached/hosts.c index a923ec71..4018a258 100644 --- a/libmemcached/hosts.c +++ b/libmemcached/hosts.c @@ -1,3 +1,14 @@ +/* LibMemcached + * Copyright (C) 2006-2010 Brian Aker + * All rights reserved. + * + * Use and distribution licensed under the BSD license. See + * the COPYING file in the parent directory for full text. + * + * Summary: + * + */ + #include "common.h" #include @@ -11,8 +22,8 @@ static memcached_return_t update_continuum(memcached_st *ptr); static int compare_servers(const void *p1, const void *p2) { int return_value; - memcached_server_st *a= (memcached_server_st *)p1; - memcached_server_st *b= (memcached_server_st *)p2; + memcached_server_instance_st a= (memcached_server_instance_st)p1; + memcached_server_instance_st b= (memcached_server_instance_st)p2; return_value= strcmp(a->hostname, b->hostname); @@ -28,8 +39,11 @@ static void sort_hosts(memcached_st *ptr) { if (memcached_server_count(ptr)) { - qsort(ptr->hosts, memcached_server_count(ptr), sizeof(memcached_server_st), compare_servers); - ptr->hosts[0].number_of_hosts= memcached_server_count(ptr); + memcached_server_write_instance_st instance; + + qsort(memcached_server_list(ptr), memcached_server_count(ptr), sizeof(memcached_server_st), compare_servers); + instance= memcached_server_instance_fetch(ptr, 0); + instance->number_of_hosts= memcached_server_count(ptr); } } @@ -55,16 +69,15 @@ memcached_return_t run_distribution(memcached_st *ptr) WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */ } - ptr->last_disconnected_server = NULL; - return MEMCACHED_SUCCESS; } -static uint32_t ketama_server_hash(const char *key, unsigned int key_length, int alignment) +static uint32_t ketama_server_hash(const char *key, size_t key_length, uint32_t alignment) { unsigned char results[16]; - md5_signature((unsigned char*)key, key_length, results); + libhashkit_md5_signature((unsigned char*)key, key_length, results); + return ((uint32_t) (results[3 + alignment * 4] & 0xFF) << 24) | ((uint32_t) (results[2 + alignment * 4] & 0xFF) << 16) | ((uint32_t) (results[1 + alignment * 4] & 0xFF) << 8) @@ -109,10 +122,10 @@ static memcached_return_t update_continuum(memcached_st *ptr) return MEMCACHED_ERRNO; } - list = ptr->hosts; + list = memcached_server_list(ptr); /* count live servers (those without a retry delay set) */ - is_auto_ejecting= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS); + is_auto_ejecting= _is_auto_eject_host(ptr); if (is_auto_ejecting) { live_servers= 0; @@ -143,8 +156,8 @@ static memcached_return_t update_continuum(memcached_st *ptr) { memcached_continuum_item_st *new_ptr; - new_ptr= ptr->call_realloc(ptr, ptr->continuum, - sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server); + new_ptr= libmemcached_realloc(ptr, ptr->continuum, + sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server); if (new_ptr == 0) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; @@ -161,12 +174,12 @@ static memcached_return_t update_continuum(memcached_st *ptr) { list[host_index].weight = 1; } - if (!is_auto_ejecting || list[host_index].next_retry <= now.tv_sec) + if (! is_auto_ejecting || list[host_index].next_retry <= now.tv_sec) total_weight += list[host_index].weight; } } - for (host_index = 0; host_index < memcached_server_count(ptr); ++host_index) + for (host_index= 0; host_index < memcached_server_count(ptr); ++host_index) { if (is_auto_ejecting && list[host_index].next_retry > now.tv_sec) continue; @@ -210,17 +223,16 @@ static memcached_return_t update_continuum(memcached_st *ptr) if (is_ketama_weighted) { - unsigned int i; - for (i = 0; i < pointer_per_hash; i++) + for (uint32_t x= 0; x < pointer_per_hash; x++) { - value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i); + value= ketama_server_hash(sort_host, sort_host_length, x); ptr->continuum[continuum_index].index= host_index; ptr->continuum[continuum_index++].value= value; } } else { - value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->distribution_hash); + value= hashkit_digest(&ptr->distribution_hashkit, sort_host, sort_host_length); ptr->continuum[continuum_index].index= host_index; ptr->continuum[continuum_index++].value= value; } @@ -255,17 +267,16 @@ static memcached_return_t update_continuum(memcached_st *ptr) if (is_ketama_weighted) { - unsigned int i; - for (i = 0; i < pointer_per_hash; i++) + for (uint32_t x = 0; x < pointer_per_hash; x++) { - value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i); + value= ketama_server_hash(sort_host, sort_host_length, x); ptr->continuum[continuum_index].index= host_index; ptr->continuum[continuum_index++].value= value; } } else { - value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->distribution_hash); + value= hashkit_digest(&ptr->distribution_hashkit, sort_host, sort_host_length); ptr->continuum[continuum_index].index= host_index; ptr->continuum[continuum_index++].value= value; } @@ -292,39 +303,48 @@ static memcached_return_t update_continuum(memcached_st *ptr) } -memcached_return_t memcached_server_push(memcached_st *ptr, memcached_server_st *list) +memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_server_list_st list) { - unsigned int x; uint32_t count; memcached_server_st *new_host_list; - if (!list) + if (! list) return MEMCACHED_SUCCESS; - count= memcached_servers_count(list); - new_host_list= ptr->call_realloc(ptr, ptr->hosts, - sizeof(memcached_server_st) * (count + memcached_server_count(ptr))); + count= memcached_server_list_count(list); + new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr), + sizeof(memcached_server_st) * (count + memcached_server_count(ptr))); if (! new_host_list) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; - ptr->hosts= new_host_list; + memcached_server_list_set(ptr, new_host_list); - for (x= 0; x < count; x++) + for (uint32_t x= 0; x < count; x++) { + memcached_server_write_instance_st instance; + if ((ptr->flags.use_udp && list[x].type != MEMCACHED_CONNECTION_UDP) || ((list[x].type == MEMCACHED_CONNECTION_UDP) && ! (ptr->flags.use_udp)) ) return MEMCACHED_INVALID_HOST_PROTOCOL; WATCHPOINT_ASSERT(list[x].hostname[0] != 0); - memcached_server_create(ptr, &ptr->hosts[memcached_server_count(ptr)]); + + instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr)); + /* TODO check return type */ - (void)memcached_server_create_with(ptr, &ptr->hosts[memcached_server_count(ptr)], list[x].hostname, + (void)memcached_server_create_with(ptr, instance, list[x].hostname, list[x].port, list[x].weight, list[x].type); ptr->number_of_hosts++; } - ptr->hosts[0].number_of_hosts= memcached_server_count(ptr); + + // Provides backwards compatibility with server list. + { + memcached_server_write_instance_st instance; + instance= memcached_server_instance_fetch(ptr, 0); + instance->number_of_hosts= memcached_server_count(ptr); + } return run_distribution(ptr); } @@ -339,7 +359,7 @@ memcached_return_t memcached_server_add_unix_socket_with_weight(memcached_st *pt const char *filename, uint32_t weight) { - if (!filename) + if (! filename) return MEMCACHED_FAILURE; return server_add(ptr, filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET); @@ -357,10 +377,10 @@ memcached_return_t memcached_server_add_udp_with_weight(memcached_st *ptr, in_port_t port, uint32_t weight) { - if (!port) + if (! port) port= MEMCACHED_DEFAULT_PORT; - if (!hostname) + if (! hostname) hostname= "localhost"; return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP); @@ -378,10 +398,10 @@ memcached_return_t memcached_server_add_with_weight(memcached_st *ptr, in_port_t port, uint32_t weight) { - if (!port) + if (! port) port= MEMCACHED_DEFAULT_PORT; - if (!hostname) + if (! hostname) hostname= "localhost"; return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_TCP); @@ -393,96 +413,27 @@ static memcached_return_t server_add(memcached_st *ptr, const char *hostname, memcached_connection_t type) { memcached_server_st *new_host_list; + memcached_server_write_instance_st instance; if ( (ptr->flags.use_udp && type != MEMCACHED_CONNECTION_UDP) || ( (type == MEMCACHED_CONNECTION_UDP) && (! ptr->flags.use_udp) ) ) return MEMCACHED_INVALID_HOST_PROTOCOL; - new_host_list= ptr->call_realloc(ptr, ptr->hosts, - sizeof(memcached_server_st) * (ptr->number_of_hosts + 1)); + new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr), + sizeof(memcached_server_st) * (ptr->number_of_hosts + 1)); if (new_host_list == NULL) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; - ptr->hosts= new_host_list; + memcached_server_list_set(ptr, new_host_list); /* TODO: Check return type */ - (void)memcached_server_create_with(ptr, &ptr->hosts[memcached_server_count(ptr)], hostname, port, weight, type); + instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr)); + (void)memcached_server_create_with(ptr, instance, hostname, port, weight, type); ptr->number_of_hosts++; - memcached_servers_set_count(&ptr->hosts[0], memcached_server_count(ptr)); + instance= memcached_server_instance_fetch(ptr, 0); + memcached_servers_set_count(instance, memcached_server_count(ptr)); return run_distribution(ptr); } - -memcached_return_t memcached_server_remove(memcached_server_st *st_ptr) -{ - uint32_t x, host_index; - memcached_st *ptr= st_ptr->root; - memcached_server_st *list= ptr->hosts; - - for (x= 0, host_index= 0; x < memcached_server_count(ptr); x++) - { - if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port) - { - if (host_index != x) - memcpy(list+host_index, list+x, sizeof(memcached_server_st)); - host_index++; - } - } - ptr->number_of_hosts= host_index; - - if (st_ptr->address_info) - { - freeaddrinfo(st_ptr->address_info); - st_ptr->address_info= NULL; - } - run_distribution(ptr); - - return MEMCACHED_SUCCESS; -} - -memcached_server_st *memcached_server_list_append(memcached_server_st *ptr, - const char *hostname, in_port_t port, - memcached_return_t *error) -{ - return memcached_server_list_append_with_weight(ptr, hostname, port, 0, error); -} - -memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr, - const char *hostname, in_port_t port, - uint32_t weight, - memcached_return_t *error) -{ - unsigned int count; - memcached_server_st *new_host_list; - - if (hostname == NULL || error == NULL) - return NULL; - - if (!port) - port= MEMCACHED_DEFAULT_PORT; - - /* Increment count for hosts */ - count= 1; - if (ptr != NULL) - { - count+= memcached_servers_count(ptr); - } - - new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count); - if (!new_host_list) - { - *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE; - return NULL; - } - - /* TODO: Check return type */ - memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP); - - /* Backwards compatibility hack */ - memcached_servers_set_count(new_host_list, count); - - *error= MEMCACHED_SUCCESS; - return new_host_list; -}