X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=46cce5657299384decd5fe3814e0d8187758fcb5;hb=cf20666bf118c2b5ed24db49992238385de009d1;hp=fcf5b51104008b27b905923d8bec0103ff78565a;hpb=35ea8bcfbe3002ad02773a2398b3683a63654d17;p=m6w6%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index fcf5b511..46cce565 100644 --- a/tests/function.c +++ b/tests/function.c @@ -1552,6 +1552,9 @@ static test_return behavior_test(memcached_st *memc) value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); assert(value > 0); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1); + assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); return 0; } @@ -3049,6 +3052,24 @@ static memcached_return pre_binary(memcached_st *memc) return rc; } +static memcached_return pre_replication(memcached_st *memc) +{ + memcached_return rc= MEMCACHED_FAILURE; + if (pre_binary(memc) == MEMCACHED_SUCCESS) + { + /* + * Make sure that we store the item on all servers + * (master + replicas == number of servers) + */ + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, + memc->number_of_hosts - 1); + assert(rc == MEMCACHED_SUCCESS); + assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1); + } + + return rc; +} + static void my_free(memcached_st *ptr __attribute__((unused)), void *mem) { free(mem); @@ -3140,6 +3161,7 @@ static memcached_return set_prefix(memcached_st *memc) return MEMCACHED_SUCCESS; } +#ifdef MEMCACHED_ENABLE_DEPRECATED static memcached_return deprecated_set_memory_alloc(memcached_st *memc) { void *test_ptr= NULL; @@ -3184,6 +3206,7 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc) } return MEMCACHED_SUCCESS; } +#endif static memcached_return set_memory_alloc(memcached_st *memc) { @@ -3550,6 +3573,179 @@ static test_return connection_pool_test(memcached_st *memc) } #endif +static test_return replication_set_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); + + rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + + /* + ** "bubba" should now be stored on all of our servers. We don't have an + ** easy to use API to address each individual server, so I'll just iterate + ** through a bunch of "master keys" and I should most likely hit all of the + ** servers... + */ + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + size_t len; + uint32_t flags; + char *val= memcached_get_by_key(clone, key, 1, "bubba", 5, + &len, &flags, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(val != NULL); + free(val); + } + + memcached_free(clone); + + return TEST_SUCCESS; +} + +static test_return replication_get_test(memcached_st *memc) +{ + memcached_return rc; + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + for (uint32_t host= 0; host < memc->number_of_hosts; ++host) + { + memcached_st *clone= memcached_clone(NULL, memc); + clone->hosts[host].port= 0; + + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + size_t len; + uint32_t flags; + char *val= memcached_get_by_key(clone, key, 1, "bubba", 5, + &len, &flags, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(val != NULL); + free(val); + } + + memcached_free(clone); + } + + return TEST_SUCCESS; +} + +static test_return replication_mget_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); + + char *keys[]= { "bubba", "key1", "key2", "key3" }; + size_t len[]= { 5, 4, 4, 4 }; + + for (int x=0; x< 4; ++x) + { + rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + } + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + memcached_result_st result_obj; + for (uint32_t host= 0; host < clone->number_of_hosts; host++) + { + memcached_st *new_clone= memcached_clone(NULL, memc); + new_clone->hosts[host].port= 0; + + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + + rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4); + assert(rc == MEMCACHED_SUCCESS); + + memcached_result_st *results= memcached_result_create(new_clone, &result_obj); + assert(results); + + int hits= 0; + while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL) + { + hits++; + } + assert(hits == 4); + memcached_result_free(&result_obj); + } + + memcached_free(new_clone); + } + + return TEST_SUCCESS; +} + +static test_return replication_delete_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + /* Delete the items from all of the servers except 1 */ + uint64_t repl= memcached_behavior_get(memc, + MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl); + + char *keys[]= { "bubba", "key1", "key2", "key3" }; + size_t len[]= { 5, 4, 4, 4 }; + + for (int x=0; x< 4; ++x) + { + rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0); + assert(rc == MEMCACHED_SUCCESS); + } + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]); + for (uint32_t x= 0; x < (repl + 1); ++x) + { + clone->hosts[hash].port= 0; + if (++hash == clone->number_of_hosts) + hash= 0; + } + + memcached_result_st result_obj; + for (uint32_t host= 0; host < clone->number_of_hosts; ++host) + { + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + + rc= memcached_mget_by_key(clone, key, 1, keys, len, 4); + assert(rc == MEMCACHED_SUCCESS); + + memcached_result_st *results= memcached_result_create(clone, &result_obj); + assert(results); + + int hits= 0; + while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL) + { + ++hits; + } + assert(hits == 4); + memcached_result_free(&result_obj); + } + } + memcached_free(clone); + + return TEST_SUCCESS; +} + static void increment_request_id(uint16_t *id) { (*id)++; @@ -3562,6 +3758,7 @@ static uint16_t *get_udp_request_ids(memcached_st *memc) uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts); assert(ids != NULL); unsigned int x; + for (x= 0; x < memc->number_of_hosts; x++) ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer); @@ -3573,6 +3770,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ unsigned int x; memcached_server_st *cur_server = memc->hosts; uint16_t *cur_req_ids = get_udp_request_ids(memc); + for (x= 0; x < memc->number_of_hosts; x++) { assert(cur_server[x].cursor_active == 0); @@ -3580,6 +3778,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ } free(expected_req_ids); free(cur_req_ids); + return TEST_SUCCESS; } @@ -3601,6 +3800,7 @@ static memcached_return init_udp(memcached_st *memc) memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts); for (x= 0; x < num_hosts; x++) memcached_server_free(&memc->hosts[x]); + memc->number_of_hosts= 0; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1); for (x= 0; x < num_hosts; x++) @@ -3608,6 +3808,7 @@ static memcached_return init_udp(memcached_st *memc) assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS); assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH); } + return MEMCACHED_SUCCESS; } @@ -3923,11 +4124,13 @@ static test_return md5_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432, - 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551, - 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895, - 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604, - 2042482093 }; + uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U, + 245758794U, 2550894432U, 121710495U, 3053817768U, + 1250994555U, 1862072655U, 2631955953U, 2951528551U, + 1451250070U, 2820856945U, 2060845566U, 3646985608U, + 2138080750U, 217675895U, 2230934345U, 1234361223U, + 3968582726U, 2455685270U, 1293568479U, 199067604U, + 2042482093U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -3945,9 +4148,10 @@ static test_return crc_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362, - 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380, - 17300, 28156, 9192, 20484, 16925 }; + uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U, + 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U, + 7621U, 30628U, 15218U, 25967U, 2695U, 9380U, + 17300U, 28156U, 9192U, 20484U, 16925U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -3964,11 +4168,13 @@ static test_return fnv1_64_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, - 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, - 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, - 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, - 1801941682 }; + uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U, + 1722477987U, 2991193800U, 4147007314U, 3633179701U, + 1805162104U, 3503289120U, 3395702895U, 3325073042U, + 2345265314U, 3340346032U, 2722964135U, 1173398992U, + 2815549194U, 2562818319U, 224996066U, 2680194749U, + 3035305390U, 246890365U, 2395624193U, 4145193337U, + 1801941682U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -3985,11 +4191,13 @@ static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582, - 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780, - 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583, - 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041, - 2272238452 }; + uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U, + 3647689787U, 3241528582U, 1669328060U, 2604311949U, + 734810122U, 1516407546U, 560948863U, 1767346780U, + 561034892U, 4156330026U, 3716417003U, 3475297030U, + 1518272172U, 227211583U, 3938128828U, 126112909U, + 3043416448U, 3131561933U, 1328739897U, 2455664041U, + 2272238452U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -4006,10 +4214,13 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986, - 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304, - 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158, - 4127558461, 1889140833, 2774173721, 1180552018 }; + uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U, + 2567703427U, 3787535528U, 4147287986U, 3500475733U, + 344481048U, 3865235296U, 2181839183U, 119581266U, + 510234242U, 4248244304U, 1362796839U, 103389328U, + 1449620010U, 182962511U, 3554262370U, 3206747549U, + 1551306158U, 4127558461U, 1889140833U, 2774173721U, + 1180552018U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -4027,10 +4238,13 @@ static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364, - 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466, - 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232, - 3579622413, 2138539289, 96429129, 2877453236 }; + uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U, + 459261019U, 3521085446U, 18738364U, 1625305005U, + 2162232970U, 777243802U, 3323728671U, 132336572U, + 3654473228U, 260679466U, 1169454059U, 2698319462U, + 1062177260U, 235516991U, 2218399068U, 405302637U, + 1128467232U, 3579622413U, 2138539289U, 96429129U, + 2877453236U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -4072,11 +4286,13 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, - 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, - 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, - 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, - 1801941682 }; + uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U, + 1722477987U, 2991193800U, 4147007314U, 3633179701U, + 1805162104U, 3503289120U, 3395702895U, 3325073042U, + 2345265314U, 3340346032U, 2722964135U, 1173398992U, + 2815549194U, 2562818319U, 224996066U, 2680194749U, + 3035305390U, 246890365U, 2395624193U, 4145193337U, + 1801941682U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -4093,11 +4309,13 @@ static test_return jenkins_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778, - 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606, - 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822, - 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387, - 2629893356 }; + uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U, + 3261968576U, 3515188778U, 4232909173U, 4288625128U, + 1812047395U, 3689182164U, 2502979932U, 1214050606U, + 2415988847U, 1494268927U, 1025545760U, 3920481083U, + 4153263658U, 3824871822U, 3072759809U, 798622255U, + 3065432577U, 1453328165U, 2691550971U, 3408888387U, + 2629893356U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -4255,6 +4473,14 @@ test_st user_tests[] ={ {0, 0, 0} }; +test_st replication_tests[]= { + {"set", 1, replication_set_test }, + {"get", 0, replication_get_test }, + {"mget", 0, replication_mget_test }, + {"delete", 0, replication_delete_test }, + {0, 0, 0} +}; + test_st generate_tests[] ={ {"generate_pairs", 1, generate_pairs }, {"generate_data", 1, generate_data }, @@ -4338,7 +4564,9 @@ collection_st collection[] ={ {"poll_timeout", poll_timeout, 0, tests}, {"gets", enable_cas, 0, tests}, {"consistent", enable_consistent, 0, tests}, +#ifdef MEMCACHED_ENABLE_DEPRECATED {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests}, +#endif {"memory_allocators", set_memory_alloc, 0, tests}, {"prefix", set_prefix, 0, tests}, {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3}, @@ -4359,6 +4587,7 @@ collection_st collection[] ={ {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests}, {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, {"test_hashes", 0, 0, hash_tests}, + {"replication", pre_replication, 0, replication_tests}, {0, 0, 0, 0} };