vinted-memcached 1.8.0

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

@@ -0,0 +1,74 @@
+/* 
+  I debated about putting this in the client library since it does an 
+  action I don't really believe belongs in the library.
+
+  Frankly its too damn useful not to be here though.
+*/
+
+#include "common.h"
+
+memcached_server_st *memcached_servers_parse(const char *server_strings)
+{
+  char *string;
+  uint32_t port;
+  uint32_t weight;
+  const char *begin_ptr;
+  const char *end_ptr;
+  memcached_server_st *servers= NULL;
+  memcached_return rc;
+
+  WATCHPOINT_ASSERT(server_strings);
+
+  end_ptr= server_strings + strlen(server_strings);
+
+  for (begin_ptr= server_strings, string= index(server_strings, ','); 
+       begin_ptr != end_ptr; 
+       string= index(begin_ptr, ','))
+  {
+    char buffer[HUGE_STRING_LEN];
+    char *ptr, *ptr2;
+    port= 0;
+    weight= 0;
+
+    if (string)
+    {
+      memcpy(buffer, begin_ptr, (size_t) (string - begin_ptr));
+      buffer[(unsigned int)(string - begin_ptr)]= 0;
+      begin_ptr= string+1;
+    }
+    else
+    {
+      size_t length= strlen(begin_ptr);
+      memcpy(buffer, begin_ptr, length);
+      buffer[length]= 0;
+      begin_ptr= end_ptr;
+    }
+
+    ptr= index(buffer, ':');
+
+    if (ptr)
+    {
+      ptr[0]= 0;
+
+      ptr++;
+
+      port= (uint32_t) strtoul(ptr, (char **)NULL, 10);
+
+      ptr2= index(ptr, ' ');
+      if (! ptr2)
+        ptr2= index(ptr, ':');
+      if (ptr2)
+      {
+        ptr2++;
+        weight = (uint32_t) strtoul(ptr2, (char **)NULL, 10);
+      }
+    }
+
+    servers= memcached_server_list_append_with_weight(servers, buffer, port, weight, &rc);
+
+    if (isspace(*begin_ptr))
+      begin_ptr++;
+  }
+
+  return servers;
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Summary: Connection pool implementation for libmemcached.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Trond Norbye
+ */
+
+#ifndef MEMCACHED_POOL_H
+#define MEMCACHED_POOL_H
+
+#include <libmemcached/memcached.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct memcached_pool_st;
+typedef struct memcached_pool_st memcached_pool_st;
+
+LIBMEMCACHED_API
+memcached_pool_st *memcached_pool_create(memcached_st* mmc, uint32_t initial, 
+                                         uint32_t max);
+LIBMEMCACHED_API
+memcached_st* memcached_pool_destroy(memcached_pool_st* pool);
+LIBMEMCACHED_API
+memcached_st* memcached_pool_pop(memcached_pool_st* pool,
+                                 bool block,
+                                 memcached_return* rc);
+LIBMEMCACHED_API
+memcached_return memcached_pool_push(memcached_pool_st* pool, 
+                                     memcached_st* mmc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MEMCACHED_POOL_H */

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

@@ -0,0 +1,76 @@
+#include "common.h"
+#include "memcached_io.h"
+#include "memcached_constants.h"
+
+memcached_return memcached_purge(memcached_server_st *ptr)
+{
+  uint32_t x;
+  memcached_return ret= MEMCACHED_SUCCESS;
+
+  if (ptr->root->purging || /* already purging */
+      (memcached_server_response_count(ptr) < ptr->root->io_msg_watermark &&
+      ptr->io_bytes_sent < ptr->root->io_bytes_watermark) ||
+      (ptr->io_bytes_sent > ptr->root->io_bytes_watermark &&
+      memcached_server_response_count(ptr) < 2))
+  {
+    return MEMCACHED_SUCCESS;
+  }
+
+  /* memcached_io_write and memcached_response may call memcached_purge
+     so we need to be able stop any recursion.. */
+  ptr->root->purging= 1;
+
+  WATCHPOINT_ASSERT(ptr->fd != -1);
+  /* Force a flush of the buffer to ensure that we don't have the n-1 pending
+     requests buffered up.. */
+  if (memcached_io_write(ptr, NULL, 0, 1) == -1)
+  {
+    ptr->root->purging= 0;
+    return MEMCACHED_WRITE_FAILURE;
+  }
+  WATCHPOINT_ASSERT(ptr->fd != -1);
+
+  uint32_t no_msg= memcached_server_response_count(ptr) - 1;
+  if (no_msg > 0)
+  {
+    memcached_result_st result;
+    memcached_result_st *result_ptr;
+    char buffer[SMALL_STRING_LEN];
+
+    /*
+     * We need to increase the timeout, because we might be waiting for
+     * data to be sent from the server (the commands was in the output buffer
+     * and just flushed
+     */
+    int32_t timeo= ptr->root->poll_timeout;
+    ptr->root->poll_timeout= 2000;
+
+    result_ptr= memcached_result_create(ptr->root, &result);
+    WATCHPOINT_ASSERT(result_ptr);
+
+    for (x= 0; x < no_msg; x++)
+    {
+      memcached_result_reset(result_ptr);
+      memcached_return rc= memcached_read_one_response(ptr, buffer,
+                                                       sizeof (buffer),
+                                                       result_ptr);
+      /*
+       * Purge doesn't care for what kind of command results that is received.
+       * The only kind of errors I care about if is I'm out of sync with the
+       * protocol or have problems reading data from the network..
+       */
+      if (rc== MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_UNKNOWN_READ_FAILURE)
+      {
+        WATCHPOINT_ERROR(rc);
+        ret = rc;
+        memcached_io_reset(ptr);
+      }
+    }
+
+    memcached_result_free(result_ptr);
+    ptr->root->poll_timeout= timeo;
+  }
+  ptr->root->purging= 0;
+
+  return ret;
+}

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

@@ -0,0 +1,75 @@
+#include "common.h"
+
+/*
+  This closes all connections (forces flush of input as well).
+  
+  Maybe add a host specific, or key specific version? 
+  
+  The reason we send "quit" is that in case we have buffered IO, this 
+  will force data to be completed.
+*/
+
+void memcached_quit_server(memcached_server_st *ptr, uint8_t io_death)
+{
+  if (ptr->fd != -1)
+  {
+    if (io_death == 0 && ptr->type != MEMCACHED_CONNECTION_UDP)
+    {
+      memcached_return rc;
+      char buffer[MEMCACHED_MAX_BUFFER];
+
+      if (ptr->root->flags & MEM_BINARY_PROTOCOL) 
+      {
+        protocol_binary_request_quit request = {.bytes= {0}};
+        request.message.header.request.magic = PROTOCOL_BINARY_REQ;
+        request.message.header.request.opcode = PROTOCOL_BINARY_CMD_QUIT;
+        request.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+        rc= memcached_do(ptr, request.bytes, sizeof(request.bytes), 1);
+      }
+      else
+        rc= memcached_do(ptr, "quit\r\n", 6, 1);
+
+      WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_FETCH_NOTFINISHED);
+      
+      /* read until socket is closed, or there is an error
+       * closing the socket before all data is read
+       * results in server throwing away all data which is
+       * not read
+       */
+      ssize_t nread;
+      while (memcached_io_read(ptr, buffer, sizeof(buffer)/sizeof(*buffer),
+                               &nread) == MEMCACHED_SUCCESS);
+    }
+    memcached_io_close(ptr);
+
+    ptr->fd= -1;
+    ptr->write_buffer_offset= (size_t) ((ptr->type == MEMCACHED_CONNECTION_UDP) ? UDP_DATAGRAM_HEADER_LENGTH : 0);
+    ptr->read_buffer_length= 0;
+    ptr->read_ptr= ptr->read_buffer;
+    memcached_server_response_reset(ptr);
+  }
+
+  if (io_death)
+  {
+    ptr->server_failure_counter++;
+  }
+  else
+  {
+    ptr->server_failure_counter = 0;
+  }
+}
+
+void memcached_quit(memcached_st *ptr)
+{
+  unsigned int x;
+
+  if (ptr->hosts == NULL || 
+      ptr->number_of_hosts == 0)
+    return;
+
+  if (ptr->hosts && ptr->number_of_hosts)
+  {
+    for (x= 0; x < ptr->number_of_hosts; x++)
+      memcached_quit_server(&ptr->hosts[x], 0);
+  }
+}