← Back to branch summary

~brianaker/libmemcached/1251482

« back to all changes in this revision

Viewing changes to libmemcached/error.cc

  • Committer: Continuous Integration
  • Date: 2013-10-11 10:57:29 UTC
  • mfrom: (1169.1.3 key-cleanup)
  • Revision ID: ci@tangent.org-20131011105729-icge7t4g8wr4g380
Merge lp:~brianaker/libmemcached/key-cleanup/ Build: jenkins-Libmemcached-369

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/error.cc
36
36
 */
37
37
 
38
38
#include <libmemcached/common.h>
 
39
 
 
40
#include "libmemcached/assert.hpp"
 
41
 
39
42
#include <cerrno>
40
43
#include <cstdarg>
41
44
#include <cstdio>
87
90
    memcached_error_free(memc);
88
91
  }
89
92
 
90
 
  // For memory allocation we use our error since it is a bit more specific
91
 
  if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
92
 
  {
93
 
    rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
94
 
  }
95
 
 
96
 
  if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
97
 
  {
98
 
    local_errno= ENOMEM;
99
 
  }
100
 
 
101
 
  if (rc == MEMCACHED_ERRNO and not local_errno)
102
 
  {
103
 
    local_errno= errno;
104
 
    rc= MEMCACHED_ERRNO;
105
 
  }
106
 
 
107
 
  if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN)
108
 
  {
109
 
    rc= MEMCACHED_CONNECTION_FAILURE;
110
 
  }
111
 
 
112
 
  if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET)
113
 
  {
114
 
    rc= MEMCACHED_CONNECTION_FAILURE;
115
 
  }
116
 
 
117
 
  if (local_errno == EINVAL)
118
 
  {
119
 
    rc= MEMCACHED_INVALID_ARGUMENTS;
120
 
  }
121
 
 
122
 
  if (local_errno == ECONNREFUSED)
123
 
  {
124
 
    rc= MEMCACHED_CONNECTION_FAILURE;
125
 
  }
126
 
 
127
 
  memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
128
 
  if (error == NULL) // Bad business if this happens
129
 
  {
130
 
    return;
131
 
  }
132
 
 
133
 
  error->root= &memc;
134
 
  error->query_id= memc.query_id;
135
 
  error->rc= rc;
136
 
  error->local_errno= local_errno;
137
 
 
138
 
  const char *errmsg_ptr;
139
 
  char errmsg[MAX_ERROR_LENGTH];
140
 
  errmsg[0]= 0;
141
 
  errmsg_ptr= errmsg;
142
 
 
143
 
  if (local_errno)
144
 
  {
 
93
  if (memcached_fatal(rc) or rc == MEMCACHED_CLIENT_ERROR)
 
94
  {
 
95
    // For memory allocation we use our error since it is a bit more specific
 
96
    if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
 
97
    {
 
98
      rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
99
    }
 
100
 
 
101
    if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
 
102
    {
 
103
      local_errno= ENOMEM;
 
104
    }
 
105
 
 
106
    if (rc == MEMCACHED_ERRNO and not local_errno)
 
107
    {
 
108
      local_errno= errno;
 
109
      rc= MEMCACHED_ERRNO;
 
110
    }
 
111
 
 
112
    if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN)
 
113
    {
 
114
      rc= MEMCACHED_CONNECTION_FAILURE;
 
115
    }
 
116
 
 
117
    if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET)
 
118
    {
 
119
      rc= MEMCACHED_CONNECTION_FAILURE;
 
120
    }
 
121
 
 
122
    if (local_errno == EINVAL)
 
123
    {
 
124
      rc= MEMCACHED_INVALID_ARGUMENTS;
 
125
    }
 
126
 
 
127
    if (local_errno == ECONNREFUSED)
 
128
    {
 
129
      rc= MEMCACHED_CONNECTION_FAILURE;
 
130
    }
 
131
 
 
132
    if (rc == MEMCACHED_TIMEOUT)
 
133
    {
 
134
    }
 
135
 
 
136
    memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
 
137
    if (error == NULL) // Bad business if this happens
 
138
    {
 
139
      assert_msg(error, "libmemcached_xmalloc() failed to allocate a memcached_error_t");
 
140
      return;
 
141
    }
 
142
 
 
143
    error->root= &memc;
 
144
    error->query_id= memc.query_id;
 
145
    error->rc= rc;
 
146
    error->local_errno= local_errno;
 
147
 
 
148
    // MEMCACHED_CLIENT_ERROR is a special case because it is an error coming from the server
 
149
    if (rc == MEMCACHED_CLIENT_ERROR)
 
150
    {
 
151
      assert(str);
 
152
      assert(str->size);
 
153
      if (str and str->size)
 
154
      {
 
155
        assert(error->local_errno == 0);
 
156
        error->local_errno= 0;
 
157
 
 
158
        error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s", 
 
159
                                   error->root,
 
160
                                   int(str->size), str->c_str);
 
161
      }
 
162
    }
 
163
    else if (local_errno)
 
164
    {
 
165
      const char *errmsg_ptr;
 
166
      char errmsg[MAX_ERROR_LENGTH];
 
167
      errmsg[0]= 0;
 
168
      errmsg_ptr= errmsg;
 
169
 
145
170
#if defined(STRERROR_R_CHAR_P) && STRERROR_R_CHAR_P
146
 
    errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg));
 
171
      errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg));
147
172
#elif defined(HAVE_STRERROR_R) && HAVE_STRERROR_R
148
 
    strerror_r(local_errno, errmsg, sizeof(errmsg));
149
 
    errmsg_ptr= errmsg;
 
173
      strerror_r(local_errno, errmsg, sizeof(errmsg));
 
174
      errmsg_ptr= errmsg;
150
175
#elif defined(HAVE_STRERROR) && HAVE_STRERROR
151
 
    snprintf(errmsg, sizeof(errmsg), "%s", strerror(local_errno));
152
 
    errmsg_ptr= errmsg;
 
176
      snprintf(errmsg, sizeof(errmsg), "%s", strerror(local_errno));
 
177
      errmsg_ptr= errmsg;
153
178
#endif
154
 
  }
155
 
 
156
 
 
157
 
  if (str and str->size and local_errno)
158
 
  {
159
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", 
160
 
                               error->root,
161
 
                               memcached_strerror(&memc, rc), 
162
 
                               errmsg_ptr,
163
 
                               memcached_string_printf(*str), at);
164
 
  }
165
 
  else if (local_errno)
166
 
  {
167
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", 
168
 
                               error->root,
169
 
                               memcached_strerror(&memc, rc), 
170
 
                               errmsg_ptr,
171
 
                               at);
172
 
  }
173
 
  else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
174
 
  {
175
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", 
176
 
                               error->root,
177
 
                               int(str->size), str->c_str, at);
178
 
  }
179
 
  else if (str and str->size)
180
 
  {
181
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", 
182
 
                               error->root,
183
 
                               memcached_strerror(&memc, rc), 
184
 
                               int(str->size), str->c_str, at);
185
 
  }
186
 
  else
187
 
  {
188
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", 
189
 
                               error->root,
190
 
                               memcached_strerror(&memc, rc), at);
191
 
  }
192
 
 
193
 
  error->next= memc.error_messages;
194
 
  memc.error_messages= error;
 
179
 
 
180
      if (str and str->size and local_errno)
 
181
      {
 
182
        error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", 
 
183
                                   error->root,
 
184
                                   memcached_strerror(&memc, rc), 
 
185
                                   errmsg_ptr,
 
186
                                   memcached_string_printf(*str), at);
 
187
      }
 
188
      else
 
189
      {
 
190
        error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", 
 
191
                                   error->root,
 
192
                                   memcached_strerror(&memc, rc), 
 
193
                                   errmsg_ptr,
 
194
                                   at);
 
195
      }
 
196
    }
 
197
    else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
 
198
    {
 
199
      error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", 
 
200
                                 error->root,
 
201
                                 int(str->size), str->c_str, at);
 
202
    }
 
203
    else if (str and str->size)
 
204
    {
 
205
      error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", 
 
206
                                 error->root,
 
207
                                 memcached_strerror(&memc, rc), 
 
208
                                 int(str->size), str->c_str, at);
 
209
    }
 
210
    else
 
211
    {
 
212
      error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", 
 
213
                                 error->root,
 
214
                                 memcached_strerror(&memc, rc), at);
 
215
    }
 
216
 
 
217
    error->next= memc.error_messages;
 
218
    memc.error_messages= error;
 
219
  }
195
220
 
196
221
#if 0
197
222
  if (error_log_fd == -1)
231
256
memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, memcached_string_t& str)
232
257
{
233
258
  assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
234
 
  if (memcached_fatal(rc) == false)
 
259
  if (memcached_fatal(rc))
235
260
  {
236
 
    return rc;
 
261
    _set(memc, &str, rc, at);
237
262
  }
238
263
 
239
 
  _set(memc, &str, rc, at);
240
 
 
241
264
  return rc;
242
265
}
243
266
 
299
322
  memcached_string_t error_host= { hostname_port_message, size_t(size) };
300
323
 
301
324
  assert_msg(self.root, "Programmer error, root was not set on instance");
302
 
  if (self.root == NULL)
 
325
  if (self.root)
303
326
  {
304
 
    return rc;
 
327
    _set(*self.root, &error_host, rc, at);
 
328
    _set(self, (*self.root));
 
329
    assert(self.error_messages);
 
330
    assert(self.root->error_messages);
 
331
    assert(self.error_messages->rc == self.root->error_messages->rc);
305
332
  }
306
333
 
307
 
  _set(*self.root, &error_host, rc, at);
308
 
  _set(self, (*self.root));
309
 
  assert(self.root->error_messages);
310
 
  assert(self.error_messages);
311
 
  assert(self.error_messages->rc == self.root->error_messages->rc);
312
 
 
313
334
  return rc;
314
335
}
315
336
 
326
347
 
327
348
  memcached_string_t error_host= { hostname_port, size};
328
349
 
329
 
  if (self.root == NULL)
 
350
  if (self.root)
330
351
  {
331
 
    return rc;
 
352
    _set(*self.root, &error_host, rc, at);
 
353
    _set(self, *self.root);
332
354
  }
333
355
 
334
 
  _set(*self.root, &error_host, rc, at);
335
 
  _set(self, *self.root);
336
 
 
337
356
  return rc;
338
357
}
339
358
 
528
547
  {
529
548
    if (memc->error_messages)
530
549
    {
531
 
      if (memc->error_messages->size == 0)
 
550
      if (memc->error_messages->size and memc->error_messages->message[0])
532
551
      {
533
552
        return memc->error_messages->message;
534
553
      }