vinted-memcached 1.8.0

data/ext/libmemcached-0.32/libmemcached/memcached_do.c

@@ -0,0 +1,72 @@
+#include "common.h"
+
+memcached_return memcached_do(memcached_server_st *ptr, const void *command,
+                              size_t command_length, uint8_t with_flush)
+{
+  memcached_return rc;
+  ssize_t sent_length;
+
+  WATCHPOINT_ASSERT(command_length);
+  WATCHPOINT_ASSERT(command);
+
+  if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
+  {
+    WATCHPOINT_ERROR(rc);
+    return rc;
+  }
+
+  /*
+  ** Since non buffering ops in UDP mode dont check to make sure they will fit
+  ** before they start writing, if there is any data in buffer, clear it out,
+  ** otherwise we might get a partial write.
+  **/
+  if (ptr->type == MEMCACHED_CONNECTION_UDP && with_flush && ptr->write_buffer_offset > UDP_DATAGRAM_HEADER_LENGTH)
+    memcached_io_write(ptr, NULL, 0, 1);
+
+  sent_length= memcached_io_write(ptr, command, command_length, (char) with_flush);
+
+  if (sent_length == -1 || (size_t)sent_length != command_length)
+    rc= MEMCACHED_WRITE_FAILURE;
+  else if ((ptr->root->flags & MEM_NOREPLY) == 0)
+    memcached_server_response_increment(ptr);
+
+  return rc;
+}
+
+memcached_return memcached_vdo(memcached_server_st *ptr,
+                               const struct libmemcached_io_vector_st *vector, size_t count,
+                               uint8_t with_flush)
+{
+  memcached_return rc;
+  ssize_t sent_length;
+	size_t command_length;
+  uint32_t x;
+
+  WATCHPOINT_ASSERT(count);
+  WATCHPOINT_ASSERT(vector);
+
+  if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
+  {
+    WATCHPOINT_ERROR(rc);
+    return rc;
+  }
+
+  if (ptr->type == MEMCACHED_CONNECTION_UDP && with_flush && ptr->write_buffer_offset > UDP_DATAGRAM_HEADER_LENGTH)
+  {
+    memcached_io_write(ptr, NULL, 0, true);
+  }
+
+  sent_length= memcached_io_writev(ptr, vector, count, (char) with_flush);
+
+  command_length = 0;
+  for (x= 0; x < count; ++x, vector++)
+    command_length+= vector->length;
+
+  if (sent_length == -1 || (size_t)sent_length != command_length) {
+    rc = MEMCACHED_WRITE_FAILURE;
+    WATCHPOINT_ERROR(rc);
+  } else if ((ptr->root->flags & MEM_NOREPLY) == 0)
+    memcached_server_response_increment(ptr);
+
+  return rc;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_dump.c

@@ -0,0 +1,79 @@
+/*
+  We use this to dump all keys.
+
+  At this point we only support a callback method. This could be optimized by first
+  calling items and finding active slabs. For the moment though we just loop through
+  all slabs on servers and "grab" the keys.
+*/
+
+#include "common.h"
+static memcached_return ascii_dump(memcached_st *ptr, memcached_dump_func *callback, void *context, uint32_t number_of_callbacks)
+{
+  memcached_return rc= 0;
+  char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+  size_t send_length;
+  uint32_t server_key;
+  uint32_t x;
+
+  unlikely (ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  for (server_key= 0; server_key < ptr->number_of_hosts; server_key++)
+  {
+    /* 256 I BELIEVE is the upper limit of slabs */
+    for (x= 0; x < 256; x++)
+    {
+      send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, 
+                                     "stats cachedump %u 0 0\r\n", x);
+
+      rc= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1);
+
+      unlikely (rc != MEMCACHED_SUCCESS)
+        goto error;
+
+      while (1)
+      {
+        uint32_t callback_counter;
+        rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+
+        if (rc == MEMCACHED_ITEM)
+        {
+          char *string_ptr, *end_ptr;
+          char *key;
+
+          string_ptr= buffer;
+          string_ptr+= 5; /* Move past ITEM */
+          for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++);
+          key= string_ptr;
+          key[(size_t)(end_ptr-string_ptr)]= 0;
+          for (callback_counter= 0; callback_counter < number_of_callbacks; callback_counter++)
+          {
+            rc= (*callback[callback_counter])(ptr, key, (size_t)(end_ptr-string_ptr), context);
+            if (rc != MEMCACHED_SUCCESS)
+              break;
+          }
+        }
+        else if (rc == MEMCACHED_END)
+          break;
+        else
+          goto error;
+      }
+    }
+  }
+
+error:
+  if (rc == MEMCACHED_END)
+    return MEMCACHED_SUCCESS;
+  else
+    return rc;
+}
+
+memcached_return memcached_dump(memcached_st *ptr, memcached_dump_func *callback, void *context, uint32_t number_of_callbacks)
+{
+  /* No support for Binary protocol yet */
+  if (ptr->flags & MEM_BINARY_PROTOCOL)
+    return MEMCACHED_FAILURE;
+
+  return ascii_dump(ptr, callback, context, number_of_callbacks);
+}
+

data/ext/libmemcached-0.32/libmemcached/memcached_exist.c

@@ -0,0 +1,114 @@
+#include <libmemcached/common.h>
+
+static memcached_return binary_exist(memcached_st *ptr, memcached_server_st *server,
+                                     const char* key, size_t key_length)
+{
+  protocol_binary_request_set request= {.bytes= {0}};
+  size_t send_length= sizeof(request.bytes);
+
+  request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+  request.message.header.request.opcode= PROTOCOL_BINARY_CMD_ADD;
+  request.message.header.request.keylen= htons((uint16_t)(ptr->prefix_key_length + key_length));
+  request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
+  request.message.header.request.extlen= 8;
+  request.message.body.flags= 0;
+  request.message.body.expiration= htonl(2678400);
+
+  request.message.header.request.bodylen= htonl((uint32_t) (key_length
+                                                            +ptr->prefix_key_length
+                                                            +request.message.header.request.extlen));
+
+
+  struct libmemcached_io_vector_st vector[]=
+  {
+    { send_length, request.bytes },
+    { strlen(ptr->prefix_key), ptr->prefix_key },
+    { key_length, key }
+  };
+
+  memcached_return rc= memcached_vdo(server, vector, 3, 1);
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    memcached_io_reset(server);
+    return (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc;
+  }
+
+  rc= memcached_response(server, NULL, 0, NULL);
+
+  if (rc == MEMCACHED_SUCCESS)
+    rc= MEMCACHED_NOTFOUND;
+
+  if (rc == MEMCACHED_DATA_EXISTS)
+    rc= MEMCACHED_SUCCESS;
+
+  return rc;
+}
+
+static memcached_return ascii_exist(memcached_st *ptr, memcached_server_st *server,
+                                     const char* key, size_t key_length)
+{
+  struct libmemcached_io_vector_st vector[]=
+  {
+    { sizeof("add ") -1, "add " },
+    { strlen(ptr->prefix_key), ptr->prefix_key },
+    { key_length, key },
+    { sizeof(" 0") -1, " 0" },
+    { sizeof(" 2678400") -1, " 2678400" },
+    { sizeof(" 0") -1, " 0" },
+    { 2, "\r\n" },
+    { 2, "\r\n" }
+  };
+
+  memcached_return rc = memcached_vdo(server, vector, 8, 1);
+
+  if (rc == MEMCACHED_SUCCESS)
+  {
+    char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+    rc= memcached_response(server, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+
+    if (rc == MEMCACHED_NOTSTORED)
+      rc= MEMCACHED_SUCCESS;
+
+    if (rc == MEMCACHED_STORED)
+      rc= MEMCACHED_NOTFOUND;
+  }
+
+  if (rc == MEMCACHED_WRITE_FAILURE)
+    memcached_io_reset(server);
+
+  return rc;
+}
+
+memcached_return memcached_exist(memcached_st *ptr, const char *key, size_t key_length)
+{
+  return memcached_exist_by_key(ptr, key, key_length, key, key_length);
+}
+
+memcached_return memcached_exist_by_key(memcached_st *ptr,
+                                        const char *group_key, size_t group_key_length,
+                                        const char *key, size_t key_length)
+{
+  unlikely (ptr->flags & MEM_USE_UDP)
+    return MEMCACHED_NOT_SUPPORTED;
+
+  if (ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  if (ptr->flags & MEM_NOREPLY)
+  {
+    size_t dummy_length;
+    uint32_t dummy_flags;
+    memcached_return dummy_error;
+
+    memcached_get(ptr, key, key_length, &dummy_length, &dummy_flags, &dummy_error);
+    return dummy_error;
+  }
+
+  unsigned int server_key= memcached_generate_hash(ptr, key, key_length);
+  memcached_server_st *server= &ptr->hosts[server_key];
+
+  if (ptr->flags & MEM_BINARY_PROTOCOL)
+    return binary_exist(ptr, server, key, key_length);
+  else
+    return ascii_exist(ptr, server, key, key_length);
+}

data/ext/libmemcached-0.32/libmemcached/memcached_exist.h

@@ -0,0 +1,20 @@
+#ifndef __MEMCACHED_EXIST_H__
+#define __MEMCACHED_EXIST_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBMEMCACHED_API
+memcached_return memcached_exist(memcached_st *memc, const char *key, size_t key_length);
+
+LIBMEMCACHED_API
+memcached_return memcached_exist_by_key(memcached_st *memc,
+                                          const char *group_key, size_t group_key_length,
+                                          const char *key, size_t key_length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MEMCACHED_EXIST_H__ */

data/ext/libmemcached-0.32/libmemcached/memcached_fetch.c

@@ -0,0 +1,102 @@
+#include "common.h"
+#include "memcached_io.h"
+
+char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, 
+                      size_t *value_length, 
+                      uint32_t *flags,
+                      memcached_return *error)
+{
+  memcached_result_st *result_buffer= &ptr->result;
+
+  unlikely (ptr->flags & MEM_USE_UDP)
+  {
+    *error= MEMCACHED_NOT_SUPPORTED;
+    return NULL;
+  }
+
+  result_buffer= memcached_fetch_result(ptr, result_buffer, error);
+
+  if (result_buffer == NULL || *error != MEMCACHED_SUCCESS)
+  {
+    WATCHPOINT_ASSERT(result_buffer == NULL);
+    *value_length= 0;
+    return NULL;
+  }
+
+  *value_length= memcached_string_length(&result_buffer->value);
+
+  if (key)
+  {
+    strncpy(key, result_buffer->key, result_buffer->key_length);
+    *key_length= result_buffer->key_length;
+  }
+
+  if (result_buffer->flags)
+    *flags= result_buffer->flags;
+  else
+    *flags= 0;
+
+  return memcached_string_c_copy(&result_buffer->value);
+}
+
+memcached_result_st *memcached_fetch_result(memcached_st *ptr,
+                                            memcached_result_st *result,
+                                            memcached_return *error)
+{
+  memcached_server_st *server;
+
+  unlikely (ptr->flags & MEM_USE_UDP)
+  {
+    *error= MEMCACHED_NOT_SUPPORTED;
+    return NULL;
+  }
+
+  if (result == NULL)
+    if ((result= memcached_result_create(ptr, NULL)) == NULL)
+      return NULL;
+
+  while ((server = memcached_io_get_readable_server(ptr)) != NULL) 
+  {
+    char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+    *error= memcached_response(server, buffer, sizeof(buffer), result);
+
+    if (*error == MEMCACHED_SUCCESS)
+      return result;
+    else if (*error == MEMCACHED_END)
+      memcached_server_response_reset(server);
+    else
+      break;
+  }
+
+  /* We have completed reading data */
+  if (result->is_allocated)
+    memcached_result_free(result);
+  else
+    memcached_string_reset(&result->value);
+
+  return NULL;
+}
+
+memcached_return memcached_fetch_execute(memcached_st *ptr, 
+                                         memcached_execute_function *callback,
+                                         void *context,
+                                         unsigned int number_of_callbacks)
+{
+  memcached_result_st *result= &ptr->result;
+  memcached_return rc= MEMCACHED_FAILURE;
+  unsigned int x;
+
+  while ((result= memcached_fetch_result(ptr, result, &rc)) != NULL) 
+  {
+    if (rc == MEMCACHED_SUCCESS)
+    {
+      for (x= 0; x < number_of_callbacks; x++)
+      {
+        rc= (*callback[x])(ptr, result, context);
+        if (rc != MEMCACHED_SUCCESS)
+          break;
+      }
+    }
+  }
+  return rc;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_flush.c

@@ -0,0 +1,89 @@
+#include "common.h"
+
+static memcached_return memcached_flush_binary(memcached_st *ptr, 
+                                               time_t expiration);
+static memcached_return memcached_flush_textual(memcached_st *ptr, 
+                                                time_t expiration);
+
+memcached_return memcached_flush(memcached_st *ptr, time_t expiration)
+{
+  memcached_return rc;
+
+  LIBMEMCACHED_MEMCACHED_FLUSH_START();
+  if (ptr->flags & MEM_BINARY_PROTOCOL)
+    rc= memcached_flush_binary(ptr, expiration);
+  else
+    rc= memcached_flush_textual(ptr, expiration);
+  LIBMEMCACHED_MEMCACHED_FLUSH_END();
+  return rc;
+}
+
+static memcached_return memcached_flush_textual(memcached_st *ptr, 
+                                                time_t expiration)
+{
+  unsigned int x;
+  size_t send_length;
+  memcached_return rc;
+  char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+
+  unlikely (ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  for (x= 0; x < ptr->number_of_hosts; x++)
+  {
+    bool no_reply= (ptr->flags & MEM_NOREPLY);
+    if (expiration)
+      send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, 
+                                     "flush_all %llu%s\r\n",
+                                     (unsigned long long)expiration, no_reply ? " noreply" : "");
+    else
+      send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, 
+                                     "flush_all%s\r\n", no_reply ? " noreply" : "");
+
+    rc= memcached_do(&ptr->hosts[x], buffer, send_length, 1);
+
+    if (rc == MEMCACHED_SUCCESS && !no_reply)
+      (void)memcached_response(&ptr->hosts[x], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+static memcached_return memcached_flush_binary(memcached_st *ptr, 
+                                               time_t expiration)
+{
+  unsigned int x;
+  protocol_binary_request_flush request= {.bytes= {0}};
+
+  unlikely (ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  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;
+  request.message.header.request.bodylen= htonl(request.message.header.request.extlen);
+  request.message.body.expiration= htonl((uint32_t) expiration);
+
+  for (x= 0; x < ptr->number_of_hosts; x++)
+  {
+    if (ptr->flags & MEM_NOREPLY)
+      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_FLUSHQ;
+    else
+      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_FLUSH;
+    if (memcached_do(&ptr->hosts[x], request.bytes, 
+                     sizeof(request.bytes), 1) != MEMCACHED_SUCCESS) 
+    {
+      memcached_io_reset(&ptr->hosts[x]);
+      return MEMCACHED_WRITE_FAILURE;
+    } 
+  }
+
+  for (x= 0; x < ptr->number_of_hosts; x++)
+  {
+    if (memcached_server_response_count(&ptr->hosts[x]) > 0)
+       (void)memcached_response(&ptr->hosts[x], NULL, 0, NULL);
+  }
+
+  return MEMCACHED_SUCCESS;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_flush_buffers.c

@@ -0,0 +1,23 @@
+#include "common.h"
+#include "memcached_io.h"
+
+memcached_return memcached_flush_buffers(memcached_st *mem)
+{
+  memcached_return ret= MEMCACHED_SUCCESS;
+  uint32_t x;
+
+  for (x= 0; x < mem->number_of_hosts; ++x)
+    if (mem->hosts[x].write_buffer_offset != 0) 
+    {
+      if (mem->hosts[x].fd == -1 &&
+          (ret= memcached_connect(&mem->hosts[x])) != MEMCACHED_SUCCESS)
+      {
+        WATCHPOINT_ERROR(ret);
+        return ret;
+      }
+      if (memcached_io_write(&mem->hosts[x], NULL, 0, 1) == -1)
+        ret= MEMCACHED_SOME_ERRORS;
+    }
+
+  return ret;
+}