uint64_t *value)
{
size_t send_length;
- memcached_return rc;
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
unsigned int server_key;
+ uint8_t replicas= 0;
+ memcached_return rc[MEMCACHED_MAX_REPLICAS];
- if (key_length == 0)
+ unlikely (key_length == 0)
return MEMCACHED_NO_KEY_PROVIDED;
- if (ptr->hosts == NULL || ptr->number_of_hosts == 0)
+ unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0)
return MEMCACHED_NO_SERVERS;
if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test(&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
"%s %.*s %u\r\n", verb,
(int)key_length, key,
offset);
- if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
+ unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
return MEMCACHED_WRITE_FAILURE;
- rc= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1);
- if (rc != MEMCACHED_SUCCESS)
- return rc;
-
- rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
-
- /*
- So why recheck responce? Because the protocol is brain dead :)
- The number returned might end up equaling one of the string
- values. Less chance of a mistake with strncmp() so we will
- use it. We still called memcached_response() though since it
- worked its magic for non-blocking IO.
- */
- if (!strncmp(buffer, "ERROR\r\n", 7))
+ do
{
- *value= 0;
- rc= MEMCACHED_PROTOCOL_ERROR;
- }
- else if (!strncmp(buffer, "NOT_FOUND\r\n", 11))
+ rc[replicas]= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1);
+ if (rc[replicas] != MEMCACHED_SUCCESS)
+ goto error;
+
+ rc[replicas]= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+
+ /*
+ So why recheck responce? Because the protocol is brain dead :)
+ The number returned might end up equaling one of the string
+ values. Less chance of a mistake with strncmp() so we will
+ use it. We still called memcached_response() though since it
+ worked its magic for non-blocking IO.
+ */
+ if (!strncmp(buffer, "ERROR\r\n", 7))
+ {
+ *value= 0;
+ rc[replicas]= MEMCACHED_PROTOCOL_ERROR;
+ }
+ else if (!strncmp(buffer, "NOT_FOUND\r\n", 11))
+ {
+ *value= 0;
+ rc[replicas]= MEMCACHED_NOTFOUND;
+ }
+ else
+ {
+ *value= (uint64_t)strtoll(buffer, (char **)NULL, 10);
+ rc[replicas]= MEMCACHED_SUCCESS;
+ }
+ /* On error we just jump to the next potential server */
+error:
+ if (replicas > 1 && ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT)
+ {
+ if (server_key == (ptr->number_of_hosts - 1))
+ server_key= 0;
+ else
+ server_key++;
+ }
+ } while ((++replicas) < ptr->number_of_replicas);
+
+ /* As long as one object gets stored, we count this as a success */
+ while (replicas--)
{
- *value= 0;
- rc= MEMCACHED_NOTFOUND;
- }
- else
- {
- *value= (uint64_t)strtoll(buffer, (char **)NULL, 10);
- rc= MEMCACHED_SUCCESS;
+ if (rc[replicas] == MEMCACHED_STORED)
+ return MEMCACHED_SUCCESS;
}
- return rc;
+ return rc[0];
}
memcached_return memcached_increment(memcached_st *ptr,
--- /dev/null
--- /dev/null
++#include "common.h"
++#include "memcached_io.h"
++
++memcached_return memcached_mget(memcached_st *ptr,
++ char **keys, size_t *key_length,
++ unsigned int number_of_keys)
++{
++ return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
++}
++
++memcached_return memcached_mget_by_key(memcached_st *ptr,
++ char *master_key, size_t master_key_length,
++ char **keys, size_t *key_length,
++ unsigned int number_of_keys)
++{
++ unsigned int x;
++ memcached_return rc= MEMCACHED_NOTFOUND;
++ char *get_command= "get ";
++ uint8_t get_command_length= 4;
++ unsigned int master_server_key= 0;
++
++ LIBMEMCACHED_MEMCACHED_MGET_START();
++ ptr->cursor_server= 0;
++
++ if (number_of_keys == 0)
++ return MEMCACHED_NOTFOUND;
++
++ if (ptr->number_of_hosts == 0)
++ return MEMCACHED_NO_SERVERS;
++
++ if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED))
++ return MEMCACHED_BAD_KEY_PROVIDED;
++
++ if (ptr->flags & MEM_SUPPORT_CAS)
++ {
++ get_command= "gets ";
++ get_command_length= 5;
++ }
++
++ if (master_key && master_key_length)
++ master_server_key= memcached_generate_hash(ptr, master_key, master_key_length);
++
++ /*
++ Here is where we pay for the non-block API. We need to remove any data sitting
++ in the queue before we start our get.
++
++ It might be optimum to bounce the connection if count > some number.
++ */
++ for (x= 0; x < ptr->number_of_hosts; x++)
++ {
++ if (memcached_server_response_count(&ptr->hosts[x]))
++ {
++ char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
++
++ if (ptr->flags & MEM_NO_BLOCK)
++ (void)memcached_io_write(&ptr->hosts[x], NULL, 0, 1);
++
++ while(memcached_server_response_count(&ptr->hosts[x]))
++ (void)memcached_response(&ptr->hosts[x], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result);
++ }
++ }
++
++ /*
++ If a server fails we warn about errors and start all over with sending keys
++ to the server.
++ */
++ for (x= 0; x < number_of_keys; x++)
++ {
++ unsigned int server_key;
++
++ if (master_server_key)
++ server_key= master_server_key;
++ else
++ server_key= memcached_generate_hash(ptr, keys[x], key_length[x]);
++
++ if (memcached_server_response_count(&ptr->hosts[server_key]) == 0)
++ {
++ rc= memcached_connect(&ptr->hosts[server_key]);
++
++ if (rc != MEMCACHED_SUCCESS)
++ continue;
++
++ if ((memcached_io_write(&ptr->hosts[server_key], get_command, get_command_length, 0)) == -1)
++ {
++ rc= MEMCACHED_SOME_ERRORS;
++ continue;
++ }
++ WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
++ memcached_server_response_increment(&ptr->hosts[server_key]);
++ WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 1);
++ }
++
++ if ((memcached_io_write(&ptr->hosts[server_key], keys[x], key_length[x], 0)) == -1)
++ {
++ memcached_server_response_reset(&ptr->hosts[server_key]);
++ rc= MEMCACHED_SOME_ERRORS;
++ continue;
++ }
++
++ if ((memcached_io_write(&ptr->hosts[server_key], " ", 1, 0)) == -1)
++ {
++ memcached_server_response_reset(&ptr->hosts[server_key]);
++ rc= MEMCACHED_SOME_ERRORS;
++ continue;
++ }
++ }
++
++ /*
++ Should we muddle on if some servers are dead?
++ */
++ for (x= 0; x < ptr->number_of_hosts; x++)
++ {
++ if (memcached_server_response_count(&ptr->hosts[x]))
++ {
++ /* We need to do something about non-connnected hosts in the future */
++ if ((memcached_io_write(&ptr->hosts[x], "\r\n", 2, 1)) == -1)
++ {
++ rc= MEMCACHED_SOME_ERRORS;
++ }
++ }
++ }
++
++ LIBMEMCACHED_MEMCACHED_MGET_END();
++ return rc;
++}
projects / awesomized / libmemcached / commitdiff
