}
static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
- const char *master_key,
- size_t master_key_length,
+ const char *group_key,
+ size_t group_key_length,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys,
bool mget_mode);
char *memcached_get_by_key(memcached_st *ptr,
- const char *master_key,
- size_t master_key_length,
+ const char *group_key,
+ size_t group_key_length,
const char *key, size_t key_length,
size_t *value_length,
uint32_t *flags,
}
/* Request the key */
- *error= memcached_mget_by_key_real(ptr, master_key, master_key_length,
+ *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
(const char * const *)&key,
&key_length, 1, false);
static memcached_return_t binary_mget_by_key(memcached_st *ptr,
uint32_t master_server_key,
- bool is_master_key_set,
+ bool is_group_key_set,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys,
bool mget_mode);
static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
- const char *master_key,
- size_t master_key_length,
+ const char *group_key,
+ size_t group_key_length,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys,
const char *get_command= "get ";
uint8_t get_command_length= 4;
unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
- bool is_master_key_set= false;
+ bool is_group_key_set= false;
+
+ memcached_return_t rc;
+ if ((rc= initialize_query(ptr)) != MEMCACHED_SUCCESS)
+ {
+ return rc;
+ }
unlikely (ptr->flags.use_udp)
return MEMCACHED_NOT_SUPPORTED;
if (number_of_keys == 0)
return MEMCACHED_NOTFOUND;
- if (memcached_server_count(ptr) == 0)
- return MEMCACHED_NO_SERVERS;
-
if (ptr->flags.verify_key && (memcached_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED))
return MEMCACHED_BAD_KEY_PROVIDED;
- if (master_key && master_key_length)
+ if (group_key && group_key_length)
{
- if (ptr->flags.verify_key && (memcached_key_test((const char * const *)&master_key, &master_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+ if (ptr->flags.verify_key && (memcached_key_test((const char * const *)&group_key, &group_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
return MEMCACHED_BAD_KEY_PROVIDED;
- master_server_key= memcached_generate_hash_with_redistribution(ptr, master_key, master_key_length);
- is_master_key_set= true;
+ master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
+ is_group_key_set= true;
}
/*
if (ptr->flags.binary_protocol)
{
- return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys,
+ return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
key_length, number_of_keys, mget_mode);
}
If a server fails we warn about errors and start all over with sending keys
to the server.
*/
- memcached_return_t rc= MEMCACHED_SUCCESS;
+ WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS);
size_t hosts_connected= 0;
for (uint32_t x= 0; x < number_of_keys; x++)
{
memcached_server_write_instance_st instance;
uint32_t server_key;
- if (is_master_key_set)
+ if (is_group_key_set)
{
server_key= master_server_key;
}
struct libmemcached_io_vector_st vector[]=
{
{ .length= get_command_length, .buffer= get_command },
- { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+ { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
{ .length= key_length[x], .buffer= keys[x] },
{ .length= 1, .buffer= " " }
};
if ((memcached_io_writev(instance, vector, 4, false)) == -1)
{
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
failures_occured_in_sending= true;
continue;
}
if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1)
{
memcached_server_response_reset(instance);
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
failures_occured_in_sending= true;
continue;
}
/* We need to do something about non-connnected hosts in the future */
if ((memcached_io_write(instance, "\r\n", 2, true)) == -1)
{
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
failures_occured_in_sending= true;
}
else
}
memcached_return_t memcached_mget_by_key(memcached_st *ptr,
- const char *master_key,
- size_t master_key_length,
+ const char *group_key,
+ size_t group_key_length,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys)
{
- return memcached_mget_by_key_real(ptr, master_key, master_key_length, keys,
+ return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys,
key_length, number_of_keys, true);
}
}
memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr,
- const char *master_key,
- size_t master_key_length,
+ const char *group_key,
+ size_t group_key_length,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys,
};
ptr->callbacks= &cb;
- rc= memcached_mget_by_key(ptr, master_key, master_key_length, keys,
+ rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys,
key_length, number_of_keys);
ptr->callbacks= original_callbacks;
return rc;
static memcached_return_t simple_binary_mget(memcached_st *ptr,
uint32_t master_server_key,
- bool is_master_key_set,
+ bool is_group_key_set,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys, bool mget_mode)
{
memcached_return_t rc= MEMCACHED_NOTFOUND;
- int flush= number_of_keys == 1;
+ bool flush= (number_of_keys == 1);
/*
If a server fails we warn about errors and start all over with sending keys
uint32_t server_key;
memcached_server_write_instance_st instance;
- if (is_master_key_set)
+ if (is_group_key_set)
{
server_key= master_server_key;
}
return vk;
}
- request.message.header.request.keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length));
+ request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
- request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + ptr->prefix_key_length));
+ request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->prefix_key)));
struct libmemcached_io_vector_st vector[]=
{
{ .length= sizeof(request.bytes), .buffer= request.bytes },
- { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+ { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
{ .length= key_length[x], .buffer= keys[x] }
};
if (memcached_io_writev(instance, vector, 3, flush) == -1)
{
memcached_server_response_reset(instance);
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
rc= MEMCACHED_SOME_ERRORS;
continue;
}
memcached_server_response_increment(instance);
if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
{
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
rc= MEMCACHED_SOME_ERRORS;
}
}
{
memcached_server_response_reset(instance);
memcached_io_reset(instance);
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
rc= MEMCACHED_SOME_ERRORS;
}
{
memcached_server_response_reset(instance);
memcached_io_reset(instance);
- fprintf(stderr, "%s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
rc= MEMCACHED_SOME_ERRORS;
}
}
.message.header.request= {
.magic= PROTOCOL_BINARY_REQ,
.opcode= PROTOCOL_BINARY_CMD_GETK,
- .keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length)),
+ .keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key))),
.datatype= PROTOCOL_BINARY_RAW_BYTES,
- .bodylen= htonl((uint32_t)(key_length[x] + ptr->prefix_key_length))
+ .bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->prefix_key)))
}
};
struct libmemcached_io_vector_st vector[]=
{
{ .length= sizeof(request.bytes), .buffer= request.bytes },
- { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+ { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
{ .length= key_length[x], .buffer= keys[x] }
};
static memcached_return_t binary_mget_by_key(memcached_st *ptr,
uint32_t master_server_key,
- bool is_master_key_set,
+ bool is_group_key_set,
const char * const *keys,
const size_t *key_length,
size_t number_of_keys,
if (ptr->number_of_replicas == 0)
{
- rc= simple_binary_mget(ptr, master_server_key, is_master_key_set,
+ rc= simple_binary_mget(ptr, master_server_key, is_group_key_set,
keys, key_length, number_of_keys, mget_mode);
}
else
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
- if (is_master_key_set)
+ if (is_group_key_set)
{
for (size_t x= 0; x < number_of_keys; x++)
{
projects / awesomized / libmemcached / blobdiff