git.m6w6.name Git - awesomized/libmemcached/blob - lib/memcached_multistorage.c

   1 /*
   2   Memcached library
   3
   4   memcached_set()
   5   memcached_replace()
   6   memcached_add()
   7
   8 */
   9
  10 #include "common.h"
  11 #include "memcached_io.h"
  12
  13 typedef enum {
  14   SET_OP,
  15   REPLACE_OP,
  16   ADD_OP,
  17   PREPEND_OP,
  18   APPEND_OP,
  19   CAS_OP,
  20 } memcached_storage_action;
  21
  22 /* Inline this */
  23 static char *storage_op_string(memcached_storage_action verb)
  24 {
  25   switch (verb)
  26   {
  27   case SET_OP:
  28     return "set";
  29   case REPLACE_OP:
  30     return "replace";
  31   case ADD_OP:
  32     return "add";
  33   case PREPEND_OP:
  34     return "prepend";
  35   case APPEND_OP:
  36     return "append";
  37   case CAS_OP:
  38     return "cas";
  39   };
  40
  41   return SET_OP;
  42 }
  43
  44 static memcached_return memcached_msend(memcached_st *ptr,
  45                                         char *master_key, size_t master_key_length,
  46                                         char **key, size_t *key_length,
  47                                         char **value, size_t *value_length,
  48                                         unsigned int number_of_keys,
  49                                         time_t expiration,
  50                                         uint32_t flags,
  51                                         uint64_t cas,
  52                                         memcached_storage_action verb)
  53 {
  54   size_t write_length;
  55   ssize_t sent_length;
  56   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
  57   unsigned int x;
  58   unsigned int master_server_key= 0;
  59   memcached_return rc= MEMCACHED_SUCCESS;
  60
  61   WATCHPOINT_ASSERT(key && key_length && value && value_length);
  62
  63   if (key_length == 0)
  64     return MEMCACHED_NO_KEY_PROVIDED;
  65
  66   if (ptr->number_of_hosts == 0)
  67     return MEMCACHED_NO_SERVERS;
  68
  69   if (master_key && master_key_length)
  70     master_server_key= memcached_generate_hash(ptr, master_key, master_key_length);
  71
  72   for (x= 0; x < number_of_keys; x++)
  73   {
  74     unsigned int server_key;
  75     memcached_return tried;
  76
  77     if (master_server_key)
  78       server_key= master_server_key;
  79     else
  80       server_key= memcached_generate_hash(ptr, key[x], key_length[x]);
  81
  82
  83     if (cas)
  84       write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
  85                              "%s %.*s %u %llu %zu %llu\r\n", storage_op_string(verb),
  86                              (int)key_length[x], key[x], flags,
  87                              (unsigned long long)expiration, value_length[x],
  88                              (unsigned long long)cas);
  89     else
  90       write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
  91                              "%s %.*s %u %llu %zu\r\n", storage_op_string(verb),
  92                              (int)key_length[x], key[x], flags,
  93                              (unsigned long long)expiration, value_length[x]);
  94
  95     if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
  96       goto error;
  97
  98     tried=  memcached_do(ptr, server_key, buffer, write_length, 0);
  99     if (tried != MEMCACHED_SUCCESS)
 100       goto error;
 101
 102     if ((sent_length= memcached_io_write(ptr, server_key, value[x], value_length[x], 0)) == -1)
 103       goto error;
 104
 105     if ((sent_length= memcached_io_write(ptr, server_key, "\r\n", 2, 0)) == -1)
 106       goto error;
 107
 108     continue;
 109
 110 error:
 111     memcached_quit_server(ptr, server_key, 1);
 112     continue;
 113   }
 114
 115   for (x= 0; x < ptr->number_of_hosts; x++)
 116   {
 117     if (memcached_server_response_count(ptr, x))
 118     {
 119       /* We need to do something about non-connnected hosts in the future */
 120       if ((memcached_io_write(ptr, x, NULL, 0, 1)) == -1)
 121       {
 122         rc= MEMCACHED_SOME_ERRORS;
 123       }
 124     }
 125   }
 126
 127   return rc;
 128 }
 129
 130 memcached_return memcached_mset(memcached_st *ptr,
 131                                 char **key, size_t *key_length,
 132                                 char **value, size_t *value_length,
 133                                 unsigned int number_of_keys,
 134                                 time_t expiration,
 135                                 uint32_t flags)
 136 {
 137   memcached_return rc;
 138   LIBMEMCACHED_MEMCACHED_SET_START();
 139   rc= memcached_msend(ptr, NULL, 0,
 140                       key, key_length, value, value_length,
 141                       number_of_keys,
 142                       expiration, flags, 0, SET_OP);
 143   LIBMEMCACHED_MEMCACHED_SET_END();
 144   return rc;
 145 }
 146
 147 memcached_return memcached_madd(memcached_st *ptr,
 148                                 char **key, size_t *key_length,
 149                                 char **value, size_t *value_length,
 150                                 unsigned int number_of_keys,
 151                                 time_t expiration,
 152                                 uint32_t flags)
 153 {
 154   memcached_return rc;
 155   LIBMEMCACHED_MEMCACHED_ADD_START();
 156   rc= memcached_msend(ptr, NULL, 0,
 157                       key, key_length, value, value_length,
 158                       number_of_keys,
 159                       expiration, flags, 0, ADD_OP);
 160   LIBMEMCACHED_MEMCACHED_ADD_END();
 161   return rc;
 162 }
 163
 164 memcached_return memcached_mreplace(memcached_st *ptr,
 165                                     char **key, size_t *key_length,
 166                                     char **value, size_t *value_length,
 167                                     unsigned int number_of_keys,
 168                                     time_t expiration,
 169                                     uint32_t flags)
 170 {
 171   memcached_return rc;
 172   LIBMEMCACHED_MEMCACHED_REPLACE_START();
 173   rc= memcached_msend(ptr, NULL, 0,
 174                       key, key_length, value, value_length,
 175                       number_of_keys,
 176                       expiration, flags, 0, REPLACE_OP);
 177   LIBMEMCACHED_MEMCACHED_REPLACE_END();
 178   return rc;
 179 }
 180
 181 memcached_return memcached_mprepend(memcached_st *ptr,
 182                                     char **key, size_t *key_length,
 183                                     char **value, size_t *value_length,
 184                                     unsigned int number_of_keys,
 185                                     time_t expiration,
 186                                     uint32_t flags)
 187 {
 188   memcached_return rc;
 189   rc= memcached_msend(ptr, NULL, 0,
 190                       key, key_length, value, value_length,
 191                       number_of_keys,
 192                       expiration, flags, 0, PREPEND_OP);
 193   return rc;
 194 }
 195
 196 memcached_return memcached_mappend(memcached_st *ptr,
 197                                    char **key, size_t *key_length,
 198                                    char **value, size_t *value_length,
 199                                    unsigned int number_of_keys,
 200                                    time_t expiration,
 201                                    uint32_t flags)
 202 {
 203   memcached_return rc;
 204   rc= memcached_msend(ptr, NULL, 0,
 205                       key, key_length, value, value_length,
 206                       number_of_keys,
 207                       expiration, flags, 0, APPEND_OP);
 208   return rc;
 209 }
 210
 211 memcached_return memcached_mcas(memcached_st *ptr,
 212                                 char **key, size_t *key_length,
 213                                 char **value, size_t *value_length,
 214                                 unsigned int number_of_keys,
 215                                 time_t expiration,
 216                                 uint32_t flags,
 217                                 uint64_t cas)
 218 {
 219   memcached_return rc;
 220   rc= memcached_msend(ptr, NULL, 0,
 221                       key, key_length, value, value_length,
 222                       number_of_keys,
 223                       expiration, flags, cas, APPEND_OP);
 224   return rc;
 225 }
 226
 227 memcached_return memcached_mset_by_key(memcached_st *ptr,
 228                                        char *master_key, size_t master_key_length,
 229                                        char **key, size_t *key_length,
 230                                        char **value, size_t *value_length,
 231                                        unsigned int number_of_keys,
 232                                        time_t expiration,
 233                                        uint32_t flags)
 234 {
 235   memcached_return rc;
 236   LIBMEMCACHED_MEMCACHED_SET_START();
 237   rc= memcached_msend(ptr, master_key, master_key_length,
 238                       key, key_length, value, value_length,
 239                       number_of_keys,
 240                       expiration, flags, 0, SET_OP);
 241   LIBMEMCACHED_MEMCACHED_SET_END();
 242   return rc;
 243 }
 244
 245 memcached_return memcached_madd_by_key(memcached_st *ptr,
 246                                        char *master_key, size_t master_key_length,
 247                                        char **key, size_t *key_length,
 248                                        char **value, size_t *value_length,
 249                                        unsigned int number_of_keys,
 250                                        time_t expiration,
 251                                        uint32_t flags)
 252 {
 253   memcached_return rc;
 254   LIBMEMCACHED_MEMCACHED_ADD_START();
 255   rc= memcached_msend(ptr, master_key, master_key_length,
 256                       key, key_length, value, value_length,
 257                       number_of_keys,
 258                       expiration, flags, 0, ADD_OP);
 259   LIBMEMCACHED_MEMCACHED_ADD_END();
 260   return rc;
 261 }
 262
 263 memcached_return memcached_mreplace_by_key(memcached_st *ptr,
 264                                            char *master_key, size_t master_key_length,
 265                                            char **key, size_t *key_length,
 266                                            char **value, size_t *value_length,
 267                                            unsigned int number_of_keys,
 268                                            time_t expiration,
 269                                            uint32_t flags)
 270 {
 271   memcached_return rc;
 272   LIBMEMCACHED_MEMCACHED_REPLACE_START();
 273   rc= memcached_msend(ptr, master_key, master_key_length,
 274                       key, key_length, value, value_length,
 275                       number_of_keys,
 276                       expiration, flags, 0, REPLACE_OP);
 277   LIBMEMCACHED_MEMCACHED_REPLACE_END();
 278   return rc;
 279 }
 280
 281 memcached_return memcached_mprepend_by_key(memcached_st *ptr,
 282                                            char *master_key, size_t master_key_length,
 283                                            char **key, size_t *key_length,
 284                                            char **value, size_t *value_length,
 285                                            unsigned int number_of_keys,
 286                                            time_t expiration,
 287                                            uint32_t flags)
 288 {
 289   memcached_return rc;
 290   rc= memcached_msend(ptr, master_key, master_key_length,
 291                       key, key_length, value, value_length,
 292                       number_of_keys,
 293                       expiration, flags, 0, PREPEND_OP);
 294   return rc;
 295 }
 296
 297 memcached_return memcached_mappend_by_key(memcached_st *ptr,
 298                                           char *master_key, size_t master_key_length,
 299                                           char **key, size_t *key_length,
 300                                           char **value, size_t *value_length,
 301                                           unsigned int number_of_keys,
 302                                           time_t expiration,
 303                                           uint32_t flags)
 304 {
 305   memcached_return rc;
 306   rc= memcached_msend(ptr, master_key, master_key_length,
 307                       key, key_length, value, value_length,
 308                       number_of_keys,
 309                       expiration, flags, 0, APPEND_OP);
 310   return rc;
 311 }
 312
 313 memcached_return memcached_mcas_by_key(memcached_st *ptr,
 314                                        char *master_key, size_t master_key_length,
 315                                        char **key, size_t *key_length,
 316                                        char **value, size_t *value_length,
 317                                        unsigned int number_of_keys,
 318                                        time_t expiration,
 319                                        uint32_t flags,
 320                                        uint64_t cas)
 321 {
 322   memcached_return rc;
 323   rc= memcached_msend(ptr, master_key, master_key_length,
 324                       key, key_length, value, value_length,
 325                       number_of_keys,
 326                       expiration, flags, cas, APPEND_OP);
 327   return rc;
 328 }