Merge in support for prefix keys in the binary protoocol.

diff --git a/ChangeLog b/ChangeLog
index 962299f4c841ea5d6e33df35caf06654b023a550..5eaabcc50c53c71f65ba22520d886c031dc55344 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,7 @@
 0.39
 
+* Add support for prefix keys to binary protocol.
+
 * Remove the undocumented call memcached_server_remove().
 
 * The undocumented call memcached_server_by_key() now returns const.

diff --git a/libmemcached/auto.c b/libmemcached/auto.c
index d94d26f102ed42c1d3b931f6a952105392776679..b4575f07ac3fee6d90d02b96f33432ecd0a9b3a4 100644 (file)
--- a/libmemcached/auto.c
+++ b/libmemcached/auto.c
@@ -108,17 +108,17 @@ static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd,
 
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= cmd;
-  request.message.header.request.keylen= htons((uint16_t) key_length);
+  request.message.header.request.keylen= htons((uint16_t)(key_length + ptr->prefix_key_length));
   request.message.header.request.extlen= 20;
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-  request.message.header.request.bodylen= htonl((uint32_t) (key_length + request.message.header.request.extlen));
+  request.message.header.request.bodylen= htonl((uint32_t)(key_length + ptr->prefix_key_length +  request.message.header.request.extlen));
   request.message.body.delta= htonll(offset);
   request.message.body.initial= htonll(initial);
   request.message.body.expiration= htonl((uint32_t) expiration);
 
   memcached_return_t rc;
-  if (((rc= memcached_do(instance, request.bytes,
-                         sizeof(request.bytes), false)) != MEMCACHED_SUCCESS) ||
+  if (((rc= memcached_do(instance, request.bytes, sizeof(request.bytes), false)) != MEMCACHED_SUCCESS) ||
+      (memcached_io_write(instance, ptr->prefix_key, ptr->prefix_key_length, false) == -1) ||
       (memcached_io_write(instance, key, key_length, true) == -1))
   {
     memcached_io_reset(instance);

diff --git a/libmemcached/delete.c b/libmemcached/delete.c
index da91f7036edabf4c67e175db19861318108a62fd..c83ea5e6f3846754b261f707059860cb99e94903 100644 (file)
--- a/libmemcached/delete.c
+++ b/libmemcached/delete.c
@@ -158,9 +158,9 @@ static inline memcached_return_t binary_delete(memcached_st *ptr,
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
   else
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETE;
-  request.message.header.request.keylen= htons((uint16_t)key_length);
+  request.message.header.request.keylen= htons((uint16_t)(key_length + ptr->prefix_key_length));
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-  request.message.header.request.bodylen= htonl((uint32_t) key_length);
+  request.message.header.request.bodylen= htonl((uint32_t)(key_length + ptr->prefix_key_length));
 
   if (ptr->flags.use_udp && ! flush)
   {
@@ -173,10 +173,9 @@ static inline memcached_return_t binary_delete(memcached_st *ptr,
 
   memcached_return_t rc= MEMCACHED_SUCCESS;
 
-  if (((rc= memcached_do(instance, request.bytes,
-                         sizeof(request.bytes), false)) != MEMCACHED_SUCCESS) ||
-      (memcached_io_write(instance, key,
-                          key_length, flush) == -1))
+  if (((rc= memcached_do(instance, request.bytes, sizeof(request.bytes), false)) != MEMCACHED_SUCCESS) ||
+      (memcached_io_write(instance, ptr->prefix_key, ptr->prefix_key_length, false) == -1) ||
+      (memcached_io_write(instance, key, key_length, flush) == -1))
   {
     memcached_io_reset(instance);
     rc= (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc;

diff --git a/libmemcached/fetch.c b/libmemcached/fetch.c
index 4359c9355bf006af53a5b1e3d999fa2d263d3483..3c819f38e00392ffa3ac21c2759edb6fdd66338b 100644 (file)
--- a/libmemcached/fetch.c
+++ b/libmemcached/fetch.c
@@ -91,13 +91,12 @@ memcached_return_t memcached_fetch_execute(memcached_st *ptr,
 {
   memcached_result_st *result= &ptr->result;
   memcached_return_t 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++)
+      for (uint32_t x= 0; x < number_of_callbacks; x++)
       {
         rc= (*callback[x])(ptr, result, context);
         if (rc != MEMCACHED_SUCCESS)

diff --git a/libmemcached/get.c b/libmemcached/get.c
index 1df6247cbbcf6b3f6d12af8e63de03aa5793e655..7d8d67684328006d6d79bb7e15757823e736204d 100644 (file)
--- a/libmemcached/get.c
+++ b/libmemcached/get.c
@@ -402,14 +402,28 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       return vk;
     }
 
-    request.message.header.request.keylen= htons((uint16_t)key_length[x]);
+    request.message.header.request.keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length));
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-    request.message.header.request.bodylen= htonl((uint32_t) key_length[x]);
+    request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + ptr->prefix_key_length));
 
-    if ((memcached_io_write(instance, request.bytes,
-                            sizeof(request.bytes), false) == -1) ||
-        (memcached_io_write(instance, keys[x],
-                            key_length[x], flush) == -1))
+    if (memcached_io_write(instance, request.bytes, sizeof(request.bytes), false) == -1)
+    {
+      memcached_server_response_reset(instance);
+      rc= MEMCACHED_SOME_ERRORS;
+      continue;
+    }
+
+    if (ptr->prefix_key_length)
+    {
+      if (memcached_io_write(instance, ptr->prefix_key, ptr->prefix_key_length, false) == -1)
+      {
+        memcached_server_response_reset(instance);
+        rc= MEMCACHED_SOME_ERRORS;
+        continue;
+      }
+    }
+
+    if (memcached_io_write(instance, keys[x], key_length[x], flush) == -1)
     {
       memcached_server_response_reset(instance);
       rc= MEMCACHED_SOME_ERRORS;
@@ -419,9 +433,10 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     /* We just want one pending response per server */
     memcached_server_response_reset(instance);
     memcached_server_response_increment(instance);
-    if ((x > 0 && x == ptr->io_key_prefetch) &&
-        memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
+    if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
+    {
       rc= MEMCACHED_SOME_ERRORS;
+    }
   }
 
   if (mget_mode)
@@ -519,9 +534,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         .message.header.request= {
           .magic= PROTOCOL_BINARY_REQ,
           .opcode= PROTOCOL_BINARY_CMD_GETK,
-          .keylen= htons((uint16_t)key_length[x]),
+          .keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length)),
           .datatype= PROTOCOL_BINARY_RAW_BYTES,
-          .bodylen= htonl((uint32_t)key_length[x])
+          .bodylen= htonl((uint32_t)(key_length[x] + ptr->prefix_key_length))
         }
       };
 
@@ -535,10 +550,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
        * that we might have processed some of the responses etc. For now,
        * just make sure we work _correctly_
      */
-      if ((memcached_io_write(instance, request.bytes,
-                              sizeof(request.bytes), false) == -1) ||
-          (memcached_io_write(instance, keys[x],
-                              key_length[x], true) == -1))
+      if ((memcached_io_write(instance, request.bytes, sizeof(request.bytes), false) == -1) ||
+          (memcached_io_write(instance, ptr->prefix_key, ptr->prefix_key_length, false) == -1) ||
+          (memcached_io_write(instance, keys[x], key_length[x], true) == -1))
       {
         memcached_io_reset(instance);
         dead_servers[server]= true;

diff --git a/libmemcached/storage.c b/libmemcached/storage.c
index abc5b7ca21af675f352984bc89ec8b93047745e0..88794596dbff1921ba81e911fd43856746250ab5 100644 (file)
--- a/libmemcached/storage.c
+++ b/libmemcached/storage.c
@@ -454,7 +454,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
 
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= get_com_code(verb, noreply);
-  request.message.header.request.keylen= htons((uint16_t)key_length);
+  request.message.header.request.keylen= htons((uint16_t)(key_length + ptr->prefix_key_length));
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
   if (verb == APPEND_OP || verb == PREPEND_OP)
     send_length -= 8; /* append & prepend does not contain extras! */
@@ -465,7 +465,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
     request.message.body.expiration= htonl((uint32_t)expiration);
   }
 
-  request.message.header.request.bodylen= htonl((uint32_t) (key_length + value_length +
+  request.message.header.request.bodylen= htonl((uint32_t) (key_length + ptr->prefix_key_length + value_length +
                                                             request.message.header.request.extlen));
 
   if (cas)
@@ -491,6 +491,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
   memcached_return_t rc;
   if (((rc= memcached_do(server, (const char*)request.bytes,
                          send_length, false)) != MEMCACHED_SUCCESS) ||
+      (memcached_io_write(server, ptr->prefix_key, ptr->prefix_key_length, false) == -1) ||
       (memcached_io_write(server, key, key_length, false) == -1) ||
       (memcached_io_write(server, value, value_length, flush) == -1))
   {