{ memcached_literal_param("incr ") },
{ memcached_array_string(instance->root->_namespace), memcached_array_size(instance->root->_namespace) },
{ key, key_length },
- { buffer, send_length },
+ { buffer, size_t(send_length) },
{ " noreply", reply ? 0 : memcached_literal_param_size(" noreply") },
{ memcached_literal_param("\r\n") }
};
}
protocol_binary_request_incr request= {}; // = {.bytes= {0}};
- request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+ initialize_binary_request(instance, request.message.header);
+
request.message.header.request.opcode= cmd;
request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(instance->root->_namespace)));
request.message.header.request.extlen= 20;
char message[MAX_ERROR_LENGTH];
};
-static void _set(memcached_server_st& server, memcached_st& memc)
+static void _set(memcached_instance_st& server, memcached_st& memc)
{
if (server.error_messages and server.error_messages->query_id != server.root->query_id)
{
return memcached_set_error(memc, rc, at, tmp);
}
-memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
{
assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
- assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
+ assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
memcached_string_t tmp= { str, length };
return memcached_set_error(self, rc, at, tmp);
return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length);
}
-static inline size_t append_host_to_string(memcached_server_st& self, char* buffer, const size_t buffer_length)
+static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length)
{
size_t size= 0;
switch (self.type)
return size;
}
-memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
{
assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
- assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
+ assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
if (memcached_fatal(rc) == false)
{
return rc;
size+= append_host_to_string(self, hostname_port_message_ptr, sizeof(hostname_port_message) -size);
- memcached_string_t error_host= { hostname_port_message, size };
+ memcached_string_t error_host= { hostname_port_message, size_t(size) };
assert(self.root);
if (self.root == NULL)
return rc;
}
-memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at)
{
- assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
+ assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
if (memcached_fatal(rc) == false)
{
return rc;
return memcached_set_errno(self, local_errno, at, tmp);
}
-memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length)
{
memcached_string_t tmp= { str, length };
return memcached_set_errno(self, local_errno, at, tmp);
return rc;
}
-memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str)
{
if (local_errno == 0)
{
return rc;
}
-memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at)
{
if (local_errno == 0)
{
self.error_messages= NULL;
}
+void memcached_error_free(memcached_instance_st& self)
+{
+ _error_free(self.error_messages);
+ self.error_messages= NULL;
+}
+
void memcached_error_free(memcached_server_st& self)
{
_error_free(self.error_messages);
return false;
}
-bool memcached_has_current_error(memcached_server_st& server)
+bool memcached_has_current_error(memcached_instance_st& server)
{
return memcached_has_current_error(*(server.root));
}
}
-memcached_error_t *memcached_error_copy(const memcached_server_st& server)
+memcached_error_t *memcached_error_copy(const memcached_instance_st& server)
{
if (server.error_messages == NULL)
{
return MEMCACHED_SUCCESS;
}
+
+memcached_return_t memcached_instance_error_return(memcached_instance_st* instance)
+{
+ if (instance == NULL)
+ {
+ return MEMCACHED_INVALID_ARGUMENTS;
+ }
+
+ if (instance and instance->error_messages)
+ {
+ return instance->error_messages->rc;
+ }
+
+ return MEMCACHED_SUCCESS;
+}
{
protocol_binary_request_flush request= {};
- request.message.header.request.magic= (uint8_t)PROTOCOL_BINARY_REQ;
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_FLUSH;
request.message.header.request.extlen= 4;
request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
{
memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+ initialize_binary_request(instance, request.message.header);
if (reply)
{
{
memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
- if (memcached_server_response_count(instance) > 0)
+ if (memcached_instance_response_count(instance) > 0)
{
(void)memcached_response(instance, NULL, 0, NULL);
}
{
{ NULL, 0 },
{ memcached_literal_param("flush_all ") },
- { buffer, send_length },
+ { buffer, size_t(send_length) },
{ " noreply", reply ? 0 : memcached_literal_param_size(" noreply") },
{ memcached_literal_param("\r\n") }
};
protocol_binary_request_set request= {};
size_t send_length= sizeof(request.bytes);
- request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+ initialize_binary_request(server, request.message.header);
+
request.message.header.request.opcode= get_com_code(verb, reply);
request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(ptr->_namespace)));
request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
{ storage_op_string(verb), strlen(storage_op_string(verb))},
{ memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
{ key, key_length },
- { flags_buffer, flags_buffer_length },
- { expiration_buffer, expiration_buffer_length },
- { value_buffer, value_buffer_length },
- { cas_buffer, cas_buffer_length },
+ { flags_buffer, size_t(flags_buffer_length) },
+ { expiration_buffer, size_t(expiration_buffer_length) },
+ { value_buffer, size_t(value_buffer_length) },
+ { cas_buffer, size_t(cas_buffer_length) },
{ " noreply", reply ? 0 : memcached_literal_param_size(" noreply") },
{ memcached_literal_param("\r\n") },
{ value, value_length },
{ memcached_literal_param("touch ") },
{ memcached_array_string(instance->root->_namespace), memcached_array_size(instance->root->_namespace) },
{ key, key_length },
- { expiration_buffer, expiration_buffer_length },
+ { expiration_buffer, size_t(expiration_buffer_length) },
{ memcached_literal_param("\r\n") }
};
time_t expiration)
{
protocol_binary_request_touch request= {}; //{.bytes= {0}};
- request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+
+ initialize_binary_request(instance, request.message.header);
+
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_TOUCH;
request.message.header.request.extlen= 4;
request.message.header.request.keylen= htons((uint16_t)(key_length +memcached_array_size(instance->root->_namespace)));
};
static memcached_return_t _set_verbosity(const memcached_st *,
- const memcached_server_st *server,
+ const memcached_server_instance_st server,
void *context)
{
libmemcached_io_vector_st *vector= (libmemcached_io_vector_st *)context;
{
{ NULL, 0 },
{ memcached_literal_param("verbosity ") },
- { buffer, send_length },
+ { buffer, size_t(send_length) },
{ memcached_literal_param("\r\n") }
};
--- /dev/null
--- /dev/null
++/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
++ *
++ * Data Differential YATL (i.e. libtest) library
++ *
++ * Copyright (C) 2012 Data Differential, http://datadifferential.com/
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are
++ * met:
++ *
++ * * Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ *
++ * * Redistributions in binary form must reproduce the above
++ * copyright notice, this list of conditions and the following disclaimer
++ * in the documentation and/or other materials provided with the
++ * distribution.
++ *
++ * * The names of its contributors may not be used to endorse or
++ * promote products derived from this software without specific prior
++ * written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ */
++
++#pragma once
++
++#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
++inline bool operator== (const memcached_st& memc, const memcached_return_t rc)
++{
++ if (memcached_last_error(&memc) == rc)
++ {
++ return true;
++ }
++
++ return false;
++}
++
++inline bool operator!= (const memcached_st& memc, const memcached_return_t rc)
++{
++ if (memcached_last_error(&memc) != rc)
++ {
++ return true;
++ }
++
++ return false;
++}
++
++inline bool operator!= (const memcached_return_t rc, const memcached_st& memc)
++{
++ if (memcached_last_error(&memc) != rc)
++ {
++ return true;
++ }
++
++ return false;
++}
++#endif
++
projects / m6w6 / libmemcached / commitdiff
