git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/error.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  LibMemcached
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include <libmemcached/common.h>
  39 #include <cstdarg>
  40
  41 #define MAX_ERROR_LENGTH 2048
  42 struct memcached_error_t
  43 {
  44   memcached_st *root;
  45   uint64_t query_id;
  46   struct memcached_error_t *next;
  47   memcached_return_t rc;
  48   int local_errno;
  49   size_t size;
  50   char message[MAX_ERROR_LENGTH];
  51 };
  52
  53 static void _set(memcached_server_st& server, memcached_st& memc)
  54 {
  55   if (server.error_messages && server.error_messages->query_id != server.root->query_id)
  56   {
  57     memcached_error_free(server);
  58   }
  59
  60   if (memc.error_messages == NULL)
  61   {
  62     return;
  63   }
  64
  65   memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
  66   if (error == NULL) // Bad business if this happens
  67   {
  68     return;
  69   }
  70
  71   memcpy(error, memc.error_messages, sizeof(memcached_error_t));
  72   error->next= server.error_messages;
  73   server.error_messages= error;
  74 }
  75
  76 #if 0
  77 static int error_log_fd= -1;
  78 #endif
  79
  80 static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t &rc, const char *at, int local_errno= 0)
  81 {
  82   if (memc.error_messages && memc.error_messages->query_id != memc.query_id)
  83   {
  84     memcached_error_free(memc);
  85   }
  86
  87   // For memory allocation we use our error since it is a bit more specific
  88   if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
  89   {
  90     rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  91   }
  92
  93   if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
  94   {
  95     local_errno= ENOMEM;
  96   }
  97
  98   if (rc == MEMCACHED_ERRNO and not local_errno)
  99   {
 100     local_errno= errno;
 101     rc= MEMCACHED_ERRNO;
 102   }
 103
 104   if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN)
 105   {
 106     rc= MEMCACHED_CONNECTION_FAILURE;
 107   }
 108
 109   if (local_errno == EINVAL)
 110   {
 111     rc= MEMCACHED_INVALID_ARGUMENTS;
 112   }
 113
 114   if (local_errno == ECONNREFUSED)
 115   {
 116     rc= MEMCACHED_CONNECTION_FAILURE;
 117   }
 118
 119   memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
 120   if (error == NULL) // Bad business if this happens
 121   {
 122     return;
 123   }
 124
 125   error->root= &memc;
 126   error->query_id= memc.query_id;
 127   error->rc= rc;
 128   error->local_errno= local_errno;
 129
 130   const char *errmsg_ptr;
 131   char errmsg[MAX_ERROR_LENGTH];
 132   errmsg[0]= 0;
 133   errmsg_ptr= errmsg;
 134
 135   if (local_errno)
 136   {
 137 #ifdef STRERROR_R_CHAR_P
 138     errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg));
 139 #else
 140     strerror_r(local_errno, errmsg, sizeof(errmsg));
 141     errmsg_ptr= errmsg;
 142 #endif
 143   }
 144
 145
 146   if (str and str->size and local_errno)
 147   {
 148     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s",
 149                                long(error->root),
 150                                memcached_strerror(&memc, rc),
 151                                errmsg_ptr,
 152                                memcached_string_printf(*str), at);
 153   }
 154   else if (local_errno)
 155   {
 156     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s",
 157                                long(error->root),
 158                                memcached_strerror(&memc, rc),
 159                                errmsg_ptr,
 160                                at);
 161   }
 162   else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
 163   {
 164     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %.*s -> %s",
 165                                long(error->root),
 166                                int(str->size), str->c_str, at);
 167   }
 168   else if (str and str->size)
 169   {
 170     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s",
 171                                long(error->root),
 172                                memcached_strerror(&memc, rc),
 173                                int(str->size), str->c_str, at);
 174   }
 175   else
 176   {
 177     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s",
 178                                long(error->root),
 179                                memcached_strerror(&memc, rc), at);
 180   }
 181
 182   error->next= memc.error_messages;
 183   memc.error_messages= error;
 184
 185 #if 0
 186   if (error_log_fd == -1)
 187   {
 188 //    unlink("/tmp/libmemcachd.log");
 189     if ((error_log_fd= open("/tmp/libmemcachd.log", O_CREAT | O_WRONLY | O_APPEND, 0644)) < 0)
 190     {
 191       perror("open");
 192       error_log_fd= -1;
 193     }
 194   }
 195   ::write(error_log_fd, error->message, error->size);
 196   ::write(error_log_fd, "\n", 1);
 197 #endif
 198 }
 199
 200 memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, const char *str, size_t length)
 201 {
 202   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
 203   memcached_string_t tmp= { str, length };
 204   return memcached_set_error(memc, rc, at, tmp);
 205 }
 206
 207 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
 208 {
 209   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
 210   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
 211
 212   memcached_string_t tmp= { str, length };
 213   return memcached_set_error(self, rc, at, tmp);
 214 }
 215
 216 memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str)
 217 {
 218   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
 219   if (memcached_fatal(rc) == false)
 220   {
 221     return rc;
 222   }
 223
 224   _set(memc, &str, rc, at);
 225
 226   return rc;
 227 }
 228
 229 memcached_return_t memcached_set_parser_error(memcached_st& memc,
 230                                               const char *at,
 231                                               const char *format, ...)
 232 {
 233   va_list args;
 234
 235   char buffer[BUFSIZ];
 236   va_start(args, format);
 237   int length= vsnprintf(buffer, sizeof(buffer), format, args);
 238   va_end(args);
 239
 240   return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length);
 241 }
 242
 243 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
 244 {
 245   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
 246   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
 247   if (memcached_fatal(rc) == false)
 248   {
 249     return rc;
 250   }
 251
 252   char hostname_port_message[MAX_ERROR_LENGTH];
 253   int size;
 254   if (str.size)
 255   {
 256     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
 257                    memcached_string_printf(str),
 258                    self.hostname, int(self.port));
 259   }
 260   else
 261   {
 262     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 263                    self.hostname, int(self.port));
 264   }
 265
 266   memcached_string_t error_host= { hostname_port_message, size };
 267
 268   assert(self.root);
 269   if (self.root == NULL)
 270   {
 271     return rc;
 272   }
 273
 274   _set(*self.root, &error_host, rc, at);
 275   _set(self, (*self.root));
 276   assert(self.root->error_messages);
 277   assert(self.error_messages);
 278
 279   return rc;
 280 }
 281
 282 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at)
 283 {
 284   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st");
 285   if (memcached_fatal(rc) == false)
 286   {
 287     return rc;
 288   }
 289
 290   char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")];
 291   int size= snprintf(hostname_port, sizeof(hostname_port), "host: %s:%d", self.hostname, int(self.port));
 292
 293   memcached_string_t error_host= { hostname_port, size};
 294
 295   if (self.root == NULL)
 296   {
 297     return rc;
 298   }
 299
 300   _set(*self.root, &error_host, rc, at);
 301   _set(self, *self.root);
 302
 303   return rc;
 304 }
 305
 306 memcached_return_t memcached_set_error(memcached_st& self, memcached_return_t rc, const char *at)
 307 {
 308   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
 309   if (memcached_fatal(rc) == false)
 310   {
 311     return rc;
 312   }
 313
 314   _set(self, NULL, rc, at);
 315
 316   return rc;
 317 }
 318
 319 memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at, const char *str, size_t length)
 320 {
 321   memcached_string_t tmp= { str, length };
 322   return memcached_set_errno(self, local_errno, at, tmp);
 323 }
 324
 325 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length)
 326 {
 327   memcached_string_t tmp= { str, length };
 328   return memcached_set_errno(self, local_errno, at, tmp);
 329 }
 330
 331 memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at)
 332 {
 333   if (local_errno == 0)
 334   {
 335     return MEMCACHED_SUCCESS;
 336   }
 337
 338   memcached_return_t rc= MEMCACHED_ERRNO;
 339   _set(self, NULL, rc, at, local_errno);
 340
 341   return rc;
 342 }
 343
 344 memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str)
 345 {
 346   if (local_errno == 0)
 347   {
 348     return MEMCACHED_SUCCESS;
 349   }
 350
 351   memcached_return_t rc= MEMCACHED_ERRNO;
 352   _set(memc, &str, rc, at, local_errno);
 353
 354   return rc;
 355 }
 356
 357 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str)
 358 {
 359   if (local_errno == 0)
 360   {
 361     return MEMCACHED_SUCCESS;
 362   }
 363
 364   char hostname_port_message[MAX_ERROR_LENGTH];
 365   int size;
 366   if (str.size)
 367   {
 368     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
 369                    memcached_string_printf(str),
 370                    self.hostname, int(self.port));
 371   }
 372   else
 373   {
 374     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 375                    self.hostname, int(self.port));
 376   }
 377
 378   memcached_string_t error_host= { hostname_port_message, size };
 379
 380   memcached_return_t rc= MEMCACHED_ERRNO;
 381   if (self.root == NULL)
 382   {
 383     return rc;
 384   }
 385
 386   _set(*self.root, &error_host, rc, at, local_errno);
 387   _set(self, (*self.root));
 388
 389   return rc;
 390 }
 391
 392 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at)
 393 {
 394   if (local_errno == 0)
 395   {
 396     return MEMCACHED_SUCCESS;
 397   }
 398
 399   char hostname_port_message[MAX_ERROR_LENGTH];
 400   int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 401                       self.hostname, int(self.port));
 402
 403   memcached_string_t error_host= { hostname_port_message, size };
 404
 405   memcached_return_t rc= MEMCACHED_ERRNO;
 406   if (self.root == NULL)
 407   {
 408     return rc;
 409   }
 410
 411   _set(*self.root, &error_host, rc, at, local_errno);
 412   _set(self, (*self.root));
 413
 414   return rc;
 415 }
 416
 417 static void _error_print(const memcached_error_t *error)
 418 {
 419   if (error == NULL)
 420   {
 421     return;
 422   }
 423
 424   if (error->size == 0)
 425   {
 426     fprintf(stderr, "\t%s\n", memcached_strerror(NULL, error->rc) );
 427   }
 428   else
 429   {
 430     fprintf(stderr, "\t%s %s\n", memcached_strerror(NULL, error->rc), error->message);
 431   }
 432
 433   _error_print(error->next);
 434 }
 435
 436 void memcached_error_print(const memcached_st *self)
 437 {
 438   if (self == NULL)
 439   {
 440     return;
 441   }
 442
 443   _error_print(self->error_messages);
 444
 445   for (uint32_t x= 0; x < memcached_server_count(self); x++)
 446   {
 447     memcached_server_instance_st instance= memcached_server_instance_by_position(self, x);
 448
 449     _error_print(instance->error_messages);
 450   }
 451 }
 452
 453 static void _error_free(memcached_error_t *error)
 454 {
 455   if (not error)
 456   {
 457     return;
 458   }
 459
 460   _error_free(error->next);
 461
 462   if (error and error->root)
 463   {
 464     libmemcached_free(error->root, error);
 465   }
 466   else if (error)
 467   {
 468     libmemcached_free(error->root, error);
 469   }
 470 }
 471
 472 void memcached_error_free(memcached_st& self)
 473 {
 474   _error_free(self.error_messages);
 475   self.error_messages= NULL;
 476 }
 477
 478 void memcached_error_free(memcached_server_st& self)
 479 {
 480   _error_free(self.error_messages);
 481   self.error_messages= NULL;
 482 }
 483
 484 const char *memcached_last_error_message(memcached_st *memc)
 485 {
 486   if (memc == NULL)
 487   {
 488     return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS);
 489   }
 490
 491   if (memc->error_messages == NULL)
 492   {
 493     return memcached_strerror(memc, MEMCACHED_SUCCESS);
 494   }
 495
 496   if (memc->error_messages->size == 0)
 497   {
 498     return memcached_strerror(memc, memc->error_messages->rc);
 499   }
 500
 501   return memc->error_messages->message;
 502 }
 503
 504 bool memcached_has_current_error(memcached_st &memc)
 505 {
 506   if (memc.error_messages
 507       and memc.error_messages->query_id == memc.query_id
 508       and memcached_failed(memc.error_messages->rc))
 509   {
 510     return true;
 511   }
 512
 513   return false;
 514 }
 515
 516 bool memcached_has_current_error(memcached_server_st& server)
 517 {
 518   return memcached_has_current_error(*(server.root));
 519 }
 520
 521 memcached_return_t memcached_last_error(memcached_st *memc)
 522 {
 523   if (memc == NULL)
 524   {
 525     return MEMCACHED_INVALID_ARGUMENTS;
 526   }
 527
 528   if (memc->error_messages == NULL)
 529   {
 530     return MEMCACHED_SUCCESS;
 531   }
 532
 533   return memc->error_messages->rc;
 534 }
 535
 536 int memcached_last_error_errno(memcached_st *memc)
 537 {
 538   if (memc == NULL)
 539   {
 540     return 0;
 541   }
 542
 543   if (memc->error_messages == NULL)
 544   {
 545     return 0;
 546   }
 547
 548   return memc->error_messages->local_errno;
 549 }
 550
 551 const char *memcached_server_error(memcached_server_instance_st server)
 552 {
 553   if (server == NULL)
 554   {
 555     return NULL;
 556   }
 557
 558   if (server->error_messages == NULL)
 559   {
 560     return memcached_strerror(server->root, MEMCACHED_SUCCESS);
 561   }
 562
 563   if (server->error_messages->size == 0)
 564   {
 565     return memcached_strerror(server->root, server->error_messages->rc);
 566   }
 567
 568   return server->error_messages->message;
 569 }
 570
 571
 572 memcached_error_t *memcached_error_copy(const memcached_server_st& server)
 573 {
 574   if (server.error_messages == NULL)
 575   {
 576     return NULL;
 577   }
 578
 579   memcached_error_t *error= libmemcached_xmalloc(server.root, memcached_error_t);
 580   memcpy(error, server.error_messages, sizeof(memcached_error_t));
 581   error->next= NULL;
 582
 583   return error;
 584 }
 585
 586 memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr)
 587 {
 588   if (ptr == NULL)
 589   {
 590     return MEMCACHED_INVALID_ARGUMENTS;
 591   }
 592
 593   if (ptr and ptr->error_messages)
 594   {
 595     return ptr->error_messages->rc;
 596   }
 597
 598   return MEMCACHED_SUCCESS;
 599 }