dalli_memcached 1.8.0

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

@@ -0,0 +1,146 @@
+/*
+ * Summary: Constants for libmemcached
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Brian Aker
+ */
+
+#ifndef __MEMCACHED_CONSTANTS_H__
+#define __MEMCACHED_CONSTANTS_H__
+
+/* Public defines */
+#define MEMCACHED_DEFAULT_PORT 11211
+#define MEMCACHED_MAX_KEY 251 /* We add one to have it null terminated */
+#define MEMCACHED_MAX_BUFFER 8196
+#define MEMCACHED_MAX_HOST_LENGTH 64
+#define MEMCACHED_MAX_HOST_SORT_LENGTH 86 /* Used for Ketama */
+#define MEMCACHED_POINTS_PER_SERVER 100
+#define MEMCACHED_POINTS_PER_SERVER_KETAMA 160
+#define MEMCACHED_CONTINUUM_SIZE MEMCACHED_POINTS_PER_SERVER*100 /* This would then set max hosts to 100 */
+#define MEMCACHED_STRIDE 4
+#define MEMCACHED_DEFAULT_TIMEOUT 1000
+#define MEMCACHED_CONTINUUM_ADDITION 10 /* How many extra slots we should build for in the continuum */
+#define MEMCACHED_PREFIX_KEY_MAX_SIZE 128
+#define MEMCACHED_EXPIRATION_NOT_ADD 0xffffffffU
+
+typedef enum {
+  MEMCACHED_SUCCESS,
+  MEMCACHED_FAILURE,
+  MEMCACHED_HOST_LOOKUP_FAILURE,
+  MEMCACHED_CONNECTION_FAILURE,
+  MEMCACHED_CONNECTION_BIND_FAILURE,
+  MEMCACHED_WRITE_FAILURE,
+  MEMCACHED_READ_FAILURE,
+  MEMCACHED_UNKNOWN_READ_FAILURE,
+  MEMCACHED_PROTOCOL_ERROR,
+  MEMCACHED_CLIENT_ERROR,
+  MEMCACHED_SERVER_ERROR,
+  MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE,
+  MEMCACHED_DATA_EXISTS,
+  MEMCACHED_DATA_DOES_NOT_EXIST,
+  MEMCACHED_NOTSTORED,
+  MEMCACHED_STORED,
+  MEMCACHED_NOTFOUND,
+  MEMCACHED_MEMORY_ALLOCATION_FAILURE,
+  MEMCACHED_PARTIAL_READ,
+  MEMCACHED_SOME_ERRORS,
+  MEMCACHED_NO_SERVERS,
+  MEMCACHED_END,
+  MEMCACHED_DELETED,
+  MEMCACHED_VALUE,
+  MEMCACHED_STAT,
+  MEMCACHED_ITEM,
+  MEMCACHED_ERRNO,
+  MEMCACHED_FAIL_UNIX_SOCKET,
+  MEMCACHED_NOT_SUPPORTED,
+  MEMCACHED_NO_KEY_PROVIDED, /* Deprecated. Use MEMCACHED_BAD_KEY_PROVIDED! */
+  MEMCACHED_FETCH_NOTFINISHED,
+  MEMCACHED_TIMEOUT,
+  MEMCACHED_BUFFERED,
+  MEMCACHED_BAD_KEY_PROVIDED,
+  MEMCACHED_INVALID_HOST_PROTOCOL,
+  MEMCACHED_SERVER_MARKED_DEAD,
+  MEMCACHED_UNKNOWN_STAT_KEY,
+  MEMCACHED_AUTH_PROBLEM,
+  MEMCACHED_AUTH_FAILURE,
+  MEMCACHED_AUTH_CONTINUE,
+  MEMCACHED_MAXIMUM_RETURN /* Always add new error code before */
+} memcached_return;
+
+typedef enum {
+  MEMCACHED_DISTRIBUTION_MODULA,
+  MEMCACHED_DISTRIBUTION_CONSISTENT,
+  MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA,
+  MEMCACHED_DISTRIBUTION_RANDOM
+} memcached_server_distribution;
+
+typedef enum {
+  MEMCACHED_BEHAVIOR_NO_BLOCK,
+  MEMCACHED_BEHAVIOR_TCP_NODELAY,
+  MEMCACHED_BEHAVIOR_HASH,
+  MEMCACHED_BEHAVIOR_KETAMA,
+  MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE,
+  MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE,
+  MEMCACHED_BEHAVIOR_CACHE_LOOKUPS,
+  MEMCACHED_BEHAVIOR_SUPPORT_CAS,
+  MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+  MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES,
+  MEMCACHED_BEHAVIOR_DISTRIBUTION,
+  MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,
+  MEMCACHED_BEHAVIOR_USER_DATA,
+  MEMCACHED_BEHAVIOR_SORT_HOSTS,
+  MEMCACHED_BEHAVIOR_VERIFY_KEY,
+  MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT,
+  MEMCACHED_BEHAVIOR_RETRY_TIMEOUT,
+  MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED,
+  MEMCACHED_BEHAVIOR_KETAMA_HASH,
+  MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+  MEMCACHED_BEHAVIOR_SND_TIMEOUT,
+  MEMCACHED_BEHAVIOR_RCV_TIMEOUT,
+  MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT,
+  MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK,
+  MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK,
+  MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH,
+  MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY,
+  MEMCACHED_BEHAVIOR_NOREPLY,
+  MEMCACHED_BEHAVIOR_USE_UDP,
+  MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
+} memcached_behavior;
+
+typedef enum {
+  MEMCACHED_CALLBACK_PREFIX_KEY = 0,
+  MEMCACHED_CALLBACK_USER_DATA = 1,
+  MEMCACHED_CALLBACK_CLEANUP_FUNCTION = 2,
+  MEMCACHED_CALLBACK_CLONE_FUNCTION = 3,
+#ifdef MEMCACHED_ENABLE_DEPRECATED
+  MEMCACHED_CALLBACK_MALLOC_FUNCTION = 4,
+  MEMCACHED_CALLBACK_REALLOC_FUNCTION = 5,
+  MEMCACHED_CALLBACK_FREE_FUNCTION = 6,
+#endif
+  MEMCACHED_CALLBACK_GET_FAILURE = 7,
+  MEMCACHED_CALLBACK_DELETE_TRIGGER = 8
+} memcached_callback;
+
+typedef enum {
+  MEMCACHED_HASH_DEFAULT= 0,
+  MEMCACHED_HASH_MD5,
+  MEMCACHED_HASH_CRC,
+  MEMCACHED_HASH_FNV1_64,
+  MEMCACHED_HASH_FNV1A_64,
+  MEMCACHED_HASH_FNV1_32,
+  MEMCACHED_HASH_FNV1A_32,
+  MEMCACHED_HASH_HSIEH,
+  MEMCACHED_HASH_MURMUR,
+  MEMCACHED_HASH_JENKINS,
+  MEMCACHED_HASH_NONE
+} memcached_hash;
+
+typedef enum {
+  MEMCACHED_CONNECTION_UNKNOWN,
+  MEMCACHED_CONNECTION_TCP,
+  MEMCACHED_CONNECTION_UDP,
+  MEMCACHED_CONNECTION_UNIX_SOCKET
+} memcached_connection;
+
+#endif /* __MEMCACHED_CONSTANTS_H__ */

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;
+}