X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fhosts.c;h=4018a2581d7846865378e583b7b0eca997fadb8e;hb=a6b4334cc16705c72da526a516f396a162cd8bfb;hp=09924f10ca9eb2920056de9e58de24d36a998072;hpb=7f9bc55d79a4e7133fdeaaa1150451717c103b28;p=awesomized%2Flibmemcached diff --git a/libmemcached/hosts.c b/libmemcached/hosts.c index 09924f10..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 @@ -6,13 +17,13 @@ static memcached_return_t server_add(memcached_st *ptr, const char *hostname, in_port_t port, uint32_t weight, memcached_connection_t type); -memcached_return_t update_continuum(memcached_st *ptr); +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); @@ -26,16 +37,22 @@ static int compare_servers(const void *p1, const void *p2) static void sort_hosts(memcached_st *ptr) { - if (ptr->number_of_hosts) + if (memcached_server_count(ptr)) { - qsort(ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st), compare_servers); - ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts; + 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); } } memcached_return_t run_distribution(memcached_st *ptr) { + if (ptr->flags.use_sort_hosts) + sort_hosts(ptr); + switch (ptr->distribution) { case MEMCACHED_DISTRIBUTION_CONSISTENT: @@ -43,8 +60,6 @@ memcached_return_t run_distribution(memcached_st *ptr) case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: return update_continuum(ptr); case MEMCACHED_DISTRIBUTION_MODULA: - if (ptr->flags.use_sort_hosts) - sort_hosts(ptr); break; case MEMCACHED_DISTRIBUTION_RANDOM: srandom((uint32_t) time(NULL)); @@ -54,36 +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; } -void server_list_free(memcached_st *ptr, memcached_server_st *servers) -{ - unsigned int x; - - if (servers == NULL) - return; - - for (x= 0; x < servers->count; x++) - if (servers[x].address_info) - { - freeaddrinfo(servers[x].address_info); - servers[x].address_info= NULL; - } - - if (ptr) - ptr->call_free(ptr, servers); - else - free(servers); -} - -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) @@ -105,7 +99,7 @@ static int continuum_item_cmp(const void *t1, const void *t2) return -1; } -memcached_return_t update_continuum(memcached_st *ptr) +static memcached_return_t update_continuum(memcached_st *ptr) { uint32_t host_index; uint32_t continuum_index= 0; @@ -128,15 +122,15 @@ 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; ptr->next_distribution_rebuild= 0; - for (host_index= 0; host_index < ptr->number_of_hosts; ++host_index) + for (host_index= 0; host_index < memcached_server_count(ptr); ++host_index) { if (list[host_index].next_retry <= now.tv_sec) live_servers++; @@ -148,7 +142,9 @@ memcached_return_t update_continuum(memcached_st *ptr) } } else - live_servers= ptr->number_of_hosts; + { + live_servers= memcached_server_count(ptr); + } is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER); @@ -160,8 +156,8 @@ 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; @@ -172,18 +168,18 @@ memcached_return_t update_continuum(memcached_st *ptr) if (is_ketama_weighted) { - for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index) + for (host_index = 0; host_index < memcached_server_count(ptr); ++host_index) { if (list[host_index].weight == 0) { 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 < ptr->number_of_hosts; ++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; @@ -227,17 +223,16 @@ 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,33 +250,33 @@ memcached_return_t update_continuum(memcached_st *ptr) if (list[host_index].port == MEMCACHED_DEFAULT_PORT) { sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH, - "%s-%d", + "%s-%u", list[host_index].hostname, pointer_index - 1); } else { sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH, - "%s:%d-%d", + "%s:%u-%u", list[host_index].hostname, - list[host_index].port, pointer_index - 1); + (uint32_t)list[host_index].port, + pointer_index - 1); } WATCHPOINT_ASSERT(sort_host_length); 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; } @@ -293,12 +288,12 @@ memcached_return_t update_continuum(memcached_st *ptr) WATCHPOINT_ASSERT(ptr); WATCHPOINT_ASSERT(ptr->continuum); - WATCHPOINT_ASSERT(ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE); + WATCHPOINT_ASSERT(memcached_server_count(ptr) * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE); ptr->continuum_points_counter= pointer_counter; qsort(ptr->continuum, ptr->continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp); #ifdef DEBUG - for (pointer_index= 0; ptr->number_of_hosts && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++) + for (pointer_index= 0; memcached_server_count(ptr) && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++) { WATCHPOINT_ASSERT(ptr->continuum[pointer_index].value <= ptr->continuum[pointer_index + 1].value); } @@ -308,39 +303,48 @@ 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; - uint16_t count; + uint32_t count; memcached_server_st *new_host_list; - if (!list) + if (! list) return MEMCACHED_SUCCESS; - count= list[0].count; - new_host_list= ptr->call_realloc(ptr, ptr->hosts, - sizeof(memcached_server_st) * (count + ptr->number_of_hosts)); + 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) + 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[ptr->number_of_hosts]); + + instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr)); + /* TODO check return type */ - (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], 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].count= (uint16_t) ptr->number_of_hosts; + + // 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); } @@ -355,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); @@ -373,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); @@ -394,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); @@ -409,108 +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[ptr->number_of_hosts], 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++; - ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts; - - 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 < ptr->number_of_hosts; 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; + instance= memcached_server_instance_fetch(ptr, 0); + memcached_servers_set_count(instance, memcached_server_count(ptr)); - 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+= ptr[0].count; - } - - 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 */ - new_host_list[0].count= (uint16_t) count; - - *error= MEMCACHED_SUCCESS; - return new_host_list; -} - -unsigned int memcached_server_list_count(memcached_server_st *ptr) -{ - if (ptr == NULL) - return 0; - - return ptr[0].count; -} - -void memcached_server_list_free(memcached_server_st *ptr) -{ - server_list_free(NULL, ptr); + return run_distribution(ptr); }