X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=da103cac923e941dc77e583c1f347d32048fe7f4;hb=a0fa9535659f0f5a9678406f47201bfd47245114;hp=3ff842496d03357cfe03904a49f197773acb67da;hpb=f563b56dafe5e44f63f4771d923ca1de6e41159b;p=awesomized%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index 3ff84249..da103cac 100644 --- a/tests/function.c +++ b/tests/function.c @@ -297,10 +297,10 @@ static test_return_t error_test(memcached_st *memc) 4269430871U, 610793021U, 527273862U, 1437122909U, 2300930706U, 2943759320U, 674306647U, 2400528935U, 54481931U, 4186304426U, 1741088401U, 2979625118U, - 4159057246U, 3425930182U}; + 4159057246U, 3425930182U, 2593724503U}; // You have updated the memcache_error messages but not updated docs/tests. - assert(MEMCACHED_MAXIMUM_RETURN == 38); + assert(MEMCACHED_MAXIMUM_RETURN == 39); for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++) { uint32_t hash_val; @@ -1224,6 +1224,112 @@ static test_return_t decrement_with_initial_test(memcached_st *memc) return TEST_SUCCESS; } +static test_return_t increment_by_key_test(memcached_st *memc) +{ + uint64_t new_number; + memcached_return rc; + const char *master_key= "foo"; + const char *key= "number"; + const char *value= "0"; + + rc= memcached_set_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + value, strlen(value), + (time_t)0, (uint32_t)0); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + + rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), + 1, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == 1); + + rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), + 1, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == 2); + + return TEST_SUCCESS; +} + +static test_return_t increment_with_initial_by_key_test(memcached_st *memc) +{ + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0) + { + uint64_t new_number; + memcached_return rc; + const char *master_key= "foo"; + const char *key= "number"; + uint64_t initial= 0; + + rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == initial); + + rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == (initial + 1)); + } + return TEST_SUCCESS; +} + +static test_return_t decrement_by_key_test(memcached_st *memc) +{ + uint64_t new_number; + memcached_return rc; + const char *master_key= "foo"; + const char *key= "number"; + const char *value= "3"; + + rc= memcached_set_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + value, strlen(value), + (time_t)0, (uint32_t)0); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + + rc= memcached_decrement_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == 2); + + rc= memcached_decrement_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == 1); + + return TEST_SUCCESS; +} + +static test_return_t decrement_with_initial_by_key_test(memcached_st *memc) +{ + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0) + { + uint64_t new_number; + memcached_return rc; + const char *master_key= "foo"; + const char *key= "number"; + uint64_t initial= 3; + + rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == initial); + + rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == (initial - 1)); + } + return TEST_SUCCESS; +} + static test_return_t quit_test(memcached_st *memc) { memcached_return rc; @@ -1463,7 +1569,7 @@ static test_return_t mget_execute(memcached_st *memc) memc->number_of_hosts= 1; int max_keys= binary ? 20480 : 1; - + char **keys= calloc((size_t)max_keys, sizeof(char*)); size_t *key_length=calloc((size_t)max_keys, sizeof(size_t)); @@ -1484,8 +1590,7 @@ static test_return_t mget_execute(memcached_st *memc) /* Try to get all of them with a large multiget */ unsigned int counter= 0; memcached_execute_function callbacks[1]= { [0]= &callback_counter }; - rc= memcached_mget_execute(memc, NULL, 0, - (const char**)keys, key_length, + rc= memcached_mget_execute(memc, (const char**)keys, key_length, (size_t)max_keys, callbacks, &counter, 1); if (binary) @@ -2591,9 +2696,9 @@ static test_return_t user_supplied_bug18(memcached_st *trash) /* verify the standard ketama set. */ for (x= 0; x < 99; x++) { - uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key)); + uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); char *hostname = memc->hosts[server_idx].hostname; - assert(strcmp(hostname, test_cases[x].server) == 0); + assert(strcmp(hostname, ketama_test_cases[x].server) == 0); } memcached_server_list_free(server_pool); @@ -2736,7 +2841,7 @@ static test_return_t auto_eject_hosts(memcached_st *trash) for (int x= 0; x < 99; x++) { - uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key)); + uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); assert(server_idx != 2); } @@ -2746,17 +2851,73 @@ static test_return_t auto_eject_hosts(memcached_st *trash) run_distribution(memc); for (int x= 0; x < 99; x++) { - uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key)); + uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); char *hostname = memc->hosts[server_idx].hostname; - assert(strcmp(hostname, test_cases[x].server) == 0); + assert(strcmp(hostname, ketama_test_cases[x].server) == 0); + } + + memcached_server_list_free(server_pool); + memcached_free(memc); + + return TEST_SUCCESS; +} + +static test_return_t output_ketama_weighted_keys(memcached_st *trash) +{ + (void) trash; + + memcached_return rc; + memcached_st *memc= memcached_create(NULL); + assert(memc); + + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); + assert(rc == MEMCACHED_SUCCESS); + + uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); + assert(value == 1); + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); + assert(rc == MEMCACHED_SUCCESS); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); + assert(value == MEMCACHED_HASH_MD5); + + + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, + MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS); + + memcached_server_st *server_pool; + server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211"); + memcached_server_push(memc, server_pool); + + FILE *fp; + if ((fp = fopen("ketama_keys.txt", "w"))) + { + // noop + } else { + printf("cannot write to file ketama_keys.txt"); + return TEST_FAILURE; } + for (int x= 0; x < 10000; x++) + { + char key[10]; + sprintf(key, "%d", x); + + uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key)); + char *hostname = memc->hosts[server_idx].hostname; + unsigned int port = memc->hosts[server_idx].port; + fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port); + } + fclose(fp); memcached_server_list_free(server_pool); memcached_free(memc); return TEST_SUCCESS; } + static test_return_t result_static(memcached_st *memc) { memcached_result_st result; @@ -4624,6 +4785,125 @@ static test_return_t jenkins_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } + +static test_return_t ketama_compatibility_libmemcached(memcached_st *trash) +{ + memcached_return rc; + uint64_t value; + int x; + memcached_server_st *server_pool; + memcached_st *memc; + + (void)trash; + + memc= memcached_create(NULL); + assert(memc); + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); + assert(rc == MEMCACHED_SUCCESS); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); + assert(value == 1); + + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, + MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED) == MEMCACHED_SUCCESS); + + assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) == + MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED); + + server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); + memcached_server_push(memc, server_pool); + + /* verify that the server list was parsed okay. */ + assert(memc->number_of_hosts == 8); + assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0); + assert(server_pool[0].port == 11211); + assert(server_pool[0].weight == 600); + assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0); + assert(server_pool[2].port == 11211); + assert(server_pool[2].weight == 200); + assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0); + assert(server_pool[7].port == 11211); + assert(server_pool[7].weight == 100); + + /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets + * us test the boundary wraparound. + */ + assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index); + + /* verify the standard ketama set. */ + for (x= 0; x < 99; x++) + { + uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); + char *hostname = memc->hosts[server_idx].hostname; + assert(strcmp(hostname, ketama_test_cases[x].server) == 0); + } + + memcached_server_list_free(server_pool); + memcached_free(memc); + + return TEST_SUCCESS; +} + +static test_return_t ketama_compatibility_spymemcached(memcached_st *trash) +{ + memcached_return rc; + uint64_t value; + int x; + memcached_server_st *server_pool; + memcached_st *memc; + + (void)trash; + + memc= memcached_create(NULL); + assert(memc); + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); + assert(rc == MEMCACHED_SUCCESS); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); + assert(value == 1); + + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, + MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS); + + assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) == + MEMCACHED_KETAMA_COMPAT_SPY); + + server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); + memcached_server_push(memc, server_pool); + + /* verify that the server list was parsed okay. */ + assert(memc->number_of_hosts == 8); + assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0); + assert(server_pool[0].port == 11211); + assert(server_pool[0].weight == 600); + assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0); + assert(server_pool[2].port == 11211); + assert(server_pool[2].weight == 200); + assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0); + assert(server_pool[7].port == 11211); + assert(server_pool[7].weight == 100); + + /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets + * us test the boundary wraparound. + */ + assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index); + + /* verify the standard ketama set. */ + for (x= 0; x < 99; x++) + { + uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key)); + char *hostname = memc->hosts[server_idx].hostname; + assert(strcmp(hostname, ketama_test_cases_spy[x].server) == 0); + } + + memcached_server_list_free(server_pool); + memcached_free(memc); + + return TEST_SUCCESS; +} + static test_return_t regression_bug_434484(memcached_st *memc) { if (pre_binary(memc) != MEMCACHED_SUCCESS) @@ -4797,6 +5077,171 @@ static test_return_t regression_bug_442914(memcached_st *memc) return TEST_SUCCESS; } +static test_return_t regression_bug_447342(memcached_st *memc) +{ + if (memc->number_of_hosts < 3 || pre_replication(memc) != MEMCACHED_SUCCESS) + return TEST_SKIPPED; + + memcached_return rc; + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2); + assert(rc == MEMCACHED_SUCCESS); + + const size_t max_keys= 100; + char **keys= calloc(max_keys, sizeof(char*)); + size_t *key_length=calloc(max_keys, sizeof(size_t)); + + for (int x= 0; x < (int)max_keys; ++x) + { + char k[251]; + key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x); + keys[x]= strdup(k); + assert(keys[x] != NULL); + rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0); + assert(rc == MEMCACHED_SUCCESS); + } + + /* + ** We are using the quiet commands to store the replicas, so we need + ** to ensure that all of them are processed before we can continue. + ** In the test we go directly from storing the object to trying to + ** receive the object from all of the different servers, so we + ** could end up in a race condition (the memcached server hasn't yet + ** processed the quiet command from the replication set when it process + ** the request from the other client (created by the clone)). As a + ** workaround for that we call memcached_quit to send the quit command + ** to the server and wait for the response ;-) If you use the test code + ** as an example for your own code, please note that you shouldn't need + ** to do this ;-) + */ + memcached_quit(memc); + + /* Verify that all messages are stored, and we didn't stuff too much + * into the servers + */ + rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys); + assert(rc == MEMCACHED_SUCCESS); + + unsigned int counter= 0; + memcached_execute_function callbacks[1]= { [0]= &callback_counter }; + rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); + /* Verify that we received all of the key/value pairs */ + assert(counter == (unsigned int)max_keys); + + memcached_quit(memc); + /* + * 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. Fake that two servers + * are dead.. + */ + unsigned int port0= memc->hosts[0].port; + unsigned int port2= memc->hosts[2].port; + memc->hosts[0].port= 0; + memc->hosts[2].port= 0; + + rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys); + assert(rc == MEMCACHED_SUCCESS); + + counter= 0; + rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); + assert(counter == (unsigned int)max_keys); + + /* restore the memc handle */ + memc->hosts[0].port= port0; + memc->hosts[2].port= port2; + + memcached_quit(memc); + + /* Remove half of the objects */ + for (int x= 0; x < (int)max_keys; ++x) + if (x & 1) + { + rc= memcached_delete(memc, keys[x], key_length[x], 0); + assert(rc == MEMCACHED_SUCCESS); + } + + memcached_quit(memc); + memc->hosts[0].port= 0; + memc->hosts[2].port= 0; + + /* now retry the command, this time we should have cache misses */ + rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys); + assert(rc == MEMCACHED_SUCCESS); + + counter= 0; + rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); + assert(counter == (unsigned int)(max_keys >> 1)); + + /* Release allocated resources */ + for (size_t x= 0; x < max_keys; ++x) + free(keys[x]); + free(keys); + free(key_length); + + /* restore the memc handle */ + memc->hosts[0].port= port0; + memc->hosts[2].port= port2; + return TEST_SUCCESS; +} + +static test_return_t regression_bug_463297(memcached_st *memc) +{ + memcached_st *memc_clone= memcached_clone(NULL, memc); + assert(memc_clone != NULL); + assert(memcached_version(memc_clone) == MEMCACHED_SUCCESS); + + if (memc_clone->hosts[0].major_version > 1 || + (memc_clone->hosts[0].major_version == 1 && + memc_clone->hosts[0].minor_version > 2)) + { + /* Binary protocol doesn't support deferred delete */ + memcached_st *bin_clone= memcached_clone(NULL, memc); + assert(bin_clone != NULL); + assert(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS); + assert(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS); + memcached_free(bin_clone); + + memcached_quit(memc_clone); + + /* If we know the server version, deferred delete should fail + * with invalid arguments */ + assert(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS); + + /* If we don't know the server version, we should get a protocol error */ + memcached_return rc= memcached_delete(memc, "foo", 3, 1); + /* but there is a bug in some of the memcached servers (1.4) that treats + * the counter as noreply so it doesn't send the proper error message + */ + assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + + /* And buffered mode should be disabled and we should get protocol error */ + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS); + rc= memcached_delete(memc, "foo", 3, 1); + assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + + /* Same goes for noreply... */ + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS); + rc= memcached_delete(memc, "foo", 3, 1); + assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + + /* but a normal request should go through (and be buffered) */ + assert((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED); + assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS); + + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS); + /* unbuffered noreply should be success */ + assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS); + /* unbuffered with reply should be not found... */ + assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS); + assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND); + } + + memcached_free(memc_clone); + return TEST_SUCCESS; +} + + /* Test memcached_server_get_last_disconnect * For a working server set, shall be NULL * For a set of non existing server, shall not be NULL @@ -4952,6 +5397,10 @@ test_st tests[] ={ {"increment_with_initial", 1, increment_with_initial_test }, {"decrement", 0, decrement_test }, {"decrement_with_initial", 1, decrement_with_initial_test }, + {"increment_by_key", 0, increment_by_key_test }, + {"increment_with_initial_by_key", 1, increment_with_initial_by_key_test }, + {"decrement_by_key", 0, decrement_by_key_test }, + {"decrement_with_initial_by_key", 1, decrement_with_initial_by_key_test }, {"quit", 0, quit_test }, {"mget", 1, mget_test }, {"mget_result", 1, mget_result_test }, @@ -5064,6 +5513,14 @@ test_st regression_tests[]= { {"lp:434843 buffered", 1, regression_bug_434843_buffered }, {"lp:421108", 1, regression_bug_421108 }, {"lp:442914", 1, regression_bug_442914 }, + {"lp:447342", 1, regression_bug_447342 }, + {"lp:463297", 1, regression_bug_463297 }, + {0, 0, 0} +}; + +test_st ketama_compatibility[]= { + {"libmemcached", 1, ketama_compatibility_libmemcached }, + {"spymemcached", 1, ketama_compatibility_spymemcached }, {0, 0, 0} }; @@ -5109,6 +5566,7 @@ test_st hsieh_availability[] ={ test_st ketama_auto_eject_hosts[] ={ {"auto_eject_hosts", 1, auto_eject_hosts }, + {"output_ketama_weighted_keys", 1, output_ketama_weighted_keys }, {0, 0, 0} }; @@ -5172,6 +5630,7 @@ collection_st collection[] ={ {"consistent_not", 0, 0, consistent_tests}, {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests}, {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, + {"ketama_compat", 0, 0, ketama_compatibility}, {"test_hashes", 0, 0, hash_tests}, {"replication", pre_replication, 0, replication_tests}, {"replication_noblock", pre_replication_noblock, 0, replication_tests},