libmemcached

Merge lp:~jc.redoutey/libmemcached/last_disconnected_server into lp:~tangent-org/libmemcached/trunk

  1. last_disconnected_server
  2. Merge into trunk
Proposed by JC Redoutey
Status: Merged
Merged at revision: not available
Proposed branch: lp:~jc.redoutey/libmemcached/last_disconnected_server
Merge into: lp:~tangent-org/libmemcached/trunk
Diff against target: 760 lines
7 files modified
docs/memcached_servers.pod (+9/-1)
libmemcached/memcached.h (+23/-22)
libmemcached/memcached_connect.c (+20/-17)
libmemcached/memcached_hosts.c (+43/-41)
libmemcached/memcached_server.c (+12/-7)
libmemcached/memcached_server.h (+7/-4)
tests/function.c (+55/-0)
To merge this branch: bzr merge lp:~jc.redoutey/libmemcached/last_disconnected_server
Reviewer Review Type Date Requested Status
Libmemcached-developers Pending
Review via email: mp+13176@code.launchpad.net
To post a comment you must log in.
Revision history for this message
JC Redoutey (jc.redoutey) wrote :

Normally, all the comments on the original patch have been fixed

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'docs/memcached_servers.pod'
2--- docs/memcached_servers.pod 2009-05-12 15:56:43 +0000
3+++ docs/memcached_servers.pod 2009-10-10 20:30:24 +0000
4@@ -1,6 +1,6 @@
5 =head1 NAME
6
7-memcached_server_count, memcached_server_list, memcached_server_add, memcached_server_push - Manage server list
8+memcached_server_count, memcached_server_list, memcached_server_add, memcached_server_push, memcached_server_get_last_disconnect - Manage server list
9
10 =head1 LIBRARY
11
12@@ -37,6 +37,9 @@
13 memcached_server_by_key (memcached_st *ptr,
14 const char *key, size_t key_length,
15 memcached_return *error);
16+ memcached_server_st *
17+ memcached_server_get_last_disconnect (memcached_st *ptr)
18+
19
20 =head1 DESCRIPTION
21
22@@ -81,6 +84,11 @@
23 should consult *error. The returning structure should be freed with
24 memcached_server_free().
25
26+memcached_server_get_last_disconnect() returns a pointer to the last server
27+for which there was a connection problem. It does not mean this particular
28+server is currently dead but if the library is reporting a server is,
29+the returned server is a very good candidate.
30+
31 =head1 RETURN
32
33 Varies, see particular functions.
34
35=== modified file 'libmemcached/memcached.h'
36--- libmemcached/memcached.h 2009-09-23 20:41:27 +0000
37+++ libmemcached/memcached.h 2009-10-10 20:30:24 +0000
38@@ -80,6 +80,7 @@
39 uint8_t hash;
40 uint32_t continuum_points_counter;
41 memcached_server_st *hosts;
42+ memcached_server_st *last_disconnected_server;
43 int32_t snd_timeout;
44 int32_t rcv_timeout;
45 uint32_t server_failure_limit;
46@@ -133,12 +134,12 @@
47 memcached_return memcached_delete(memcached_st *ptr, const char *key, size_t key_length,
48 time_t expiration);
49 LIBMEMCACHED_API
50-memcached_return memcached_increment(memcached_st *ptr,
51+memcached_return memcached_increment(memcached_st *ptr,
52 const char *key, size_t key_length,
53 uint32_t offset,
54 uint64_t *value);
55 LIBMEMCACHED_API
56-memcached_return memcached_decrement(memcached_st *ptr,
57+memcached_return memcached_decrement(memcached_st *ptr,
58 const char *key, size_t key_length,
59 uint32_t offset,
60 uint64_t *value);
61@@ -163,7 +164,7 @@
62 LIBMEMCACHED_API
63 memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_return *error);
64 LIBMEMCACHED_API
65-memcached_return memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
66+memcached_return memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
67 char *hostname, unsigned int port);
68 LIBMEMCACHED_API
69 memcached_return memcached_flush(memcached_st *ptr, time_t expiration);
70@@ -190,27 +191,27 @@
71 /* Server Public functions */
72
73 LIBMEMCACHED_API
74-memcached_return memcached_server_add_udp(memcached_st *ptr,
75+memcached_return memcached_server_add_udp(memcached_st *ptr,
76 const char *hostname,
77 unsigned int port);
78 LIBMEMCACHED_API
79-memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
80+memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
81 const char *filename);
82 LIBMEMCACHED_API
83-memcached_return memcached_server_add(memcached_st *ptr, const char *hostname,
84+memcached_return memcached_server_add(memcached_st *ptr, const char *hostname,
85 unsigned int port);
86
87 LIBMEMCACHED_API
88-memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
89+memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
90 const char *hostname,
91 unsigned int port,
92 uint32_t weight);
93 LIBMEMCACHED_API
94-memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
95+memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
96 const char *filename,
97 uint32_t weight);
98 LIBMEMCACHED_API
99-memcached_return memcached_server_add_with_weight(memcached_st *ptr, const char *hostname,
100+memcached_return memcached_server_add_with_weight(memcached_st *ptr, const char *hostname,
101 unsigned int port,
102 uint32_t weight);
103 LIBMEMCACHED_API
104@@ -219,14 +220,14 @@
105 memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list);
106
107 LIBMEMCACHED_API
108-memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
109- const char *hostname,
110- unsigned int port,
111+memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
112+ const char *hostname,
113+ unsigned int port,
114 memcached_return *error);
115 LIBMEMCACHED_API
116-memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
117- const char *hostname,
118- unsigned int port,
119+memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
120+ const char *hostname,
121+ unsigned int port,
122 uint32_t weight,
123 memcached_return *error);
124 LIBMEMCACHED_API
125@@ -235,30 +236,30 @@
126 memcached_server_st *memcached_servers_parse(const char *server_strings);
127
128 LIBMEMCACHED_API
129-char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *memc_stat,
130+char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *memc_stat,
131 const char *key, memcached_return *error);
132 LIBMEMCACHED_API
133-char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *memc_stat,
134+char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *memc_stat,
135 memcached_return *error);
136
137 LIBMEMCACHED_API
138-memcached_return memcached_delete_by_key(memcached_st *ptr,
139+memcached_return memcached_delete_by_key(memcached_st *ptr,
140 const char *master_key, size_t master_key_length,
141 const char *key, size_t key_length,
142 time_t expiration);
143
144 LIBMEMCACHED_API
145-memcached_return memcached_fetch_execute(memcached_st *ptr,
146+memcached_return memcached_fetch_execute(memcached_st *ptr,
147 memcached_execute_function *callback,
148 void *context,
149 unsigned int number_of_callbacks);
150
151 LIBMEMCACHED_API
152-memcached_return memcached_callback_set(memcached_st *ptr,
153- memcached_callback flag,
154+memcached_return memcached_callback_set(memcached_st *ptr,
155+ memcached_callback flag,
156 void *data);
157 LIBMEMCACHED_API
158-void *memcached_callback_get(memcached_st *ptr,
159+void *memcached_callback_get(memcached_st *ptr,
160 memcached_callback flag,
161 memcached_return *error);
162
163
164=== modified file 'libmemcached/memcached_connect.c'
165--- libmemcached/memcached_connect.c 2009-09-15 21:09:32 +0000
166+++ libmemcached/memcached_connect.c 2009-10-10 20:30:24 +0000
167@@ -60,7 +60,7 @@
168 waittime.tv_sec= 0;
169 waittime.tv_usec= ptr->root->snd_timeout;
170
171- error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDTIMEO,
172+ error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDTIMEO,
173 &waittime, (socklen_t)sizeof(struct timeval));
174 WATCHPOINT_ASSERT(error == 0);
175 }
176@@ -75,7 +75,7 @@
177 waittime.tv_sec= 0;
178 waittime.tv_usec= ptr->root->rcv_timeout;
179
180- error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVTIMEO,
181+ error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVTIMEO,
182 &waittime, (socklen_t)sizeof(struct timeval));
183 WATCHPOINT_ASSERT(error == 0);
184 }
185@@ -86,9 +86,9 @@
186 int error;
187 struct linger linger;
188
189- linger.l_onoff= 1;
190- linger.l_linger= 0; /* By default on close() just drop the socket */
191- error= setsockopt(ptr->fd, SOL_SOCKET, SO_LINGER,
192+ linger.l_onoff= 1;
193+ linger.l_linger= 0; /* By default on close() just drop the socket */
194+ error= setsockopt(ptr->fd, SOL_SOCKET, SO_LINGER,
195 &linger, (socklen_t)sizeof(struct linger));
196 WATCHPOINT_ASSERT(error == 0);
197 }
198@@ -98,7 +98,7 @@
199 int flag= 1;
200 int error;
201
202- error= setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY,
203+ error= setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY,
204 &flag, (socklen_t)sizeof(int));
205 WATCHPOINT_ASSERT(error == 0);
206 }
207@@ -107,7 +107,7 @@
208 {
209 int error;
210
211- error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF,
212+ error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF,
213 &ptr->root->send_size, (socklen_t)sizeof(int));
214 WATCHPOINT_ASSERT(error == 0);
215 }
216@@ -116,7 +116,7 @@
217 {
218 int error;
219
220- error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVBUF,
221+ error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVBUF,
222 &ptr->root->recv_size, (socklen_t)sizeof(int));
223 WATCHPOINT_ASSERT(error == 0);
224 }
225@@ -156,7 +156,7 @@
226 addrlen= (socklen_t) (strlen(servAddr.sun_path) + sizeof(servAddr.sun_family));
227
228 test_connect:
229- if (connect(ptr->fd,
230+ if (connect(ptr->fd,
231 (struct sockaddr *)&servAddr,
232 sizeof(servAddr)) < 0)
233 {
234@@ -208,8 +208,8 @@
235 continue;
236 }
237
238- if ((ptr->fd= socket(use->ai_family,
239- use->ai_socktype,
240+ if ((ptr->fd= socket(use->ai_family,
241+ use->ai_socktype,
242 use->ai_protocol)) < 0)
243 {
244 ptr->cached_errno= errno;
245@@ -228,7 +228,7 @@
246 }
247
248 /* connect to server */
249- while (ptr->fd != -1 &&
250+ while (ptr->fd != -1 &&
251 connect(ptr->fd, use->ai_addr, use->ai_addrlen) < 0)
252 {
253 ptr->cached_errno= errno;
254@@ -253,23 +253,23 @@
255 (void)close(ptr->fd);
256 ptr->fd= -1;
257 }
258- }
259+ }
260 else if (errno == EISCONN) /* we are connected :-) */
261 {
262 break;
263- }
264+ }
265 else if (errno != EINTR)
266 {
267 (void)close(ptr->fd);
268 ptr->fd= -1;
269 break;
270- }
271+ }
272 }
273
274 if (ptr->fd != -1)
275 {
276- /* restore flags */
277- if (ptr->root->connect_timeout && (ptr->root->flags & MEM_NO_BLOCK) == 0)
278+ /* restore flags */
279+ if (ptr->root->connect_timeout && (ptr->root->flags & MEM_NO_BLOCK) == 0)
280 (void)fcntl(ptr->fd, F_SETFL, flags & ~O_NONBLOCK);
281
282 WATCHPOINT_ASSERT(ptr->cursor_active == 0);
283@@ -326,6 +326,7 @@
284 if (memcached_behavior_get(ptr->root, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
285 run_distribution(ptr->root);
286
287+ ptr->root->last_disconnected_server = ptr;
288 return MEMCACHED_SERVER_MARKED_DEAD;
289 }
290 }
291@@ -348,6 +349,8 @@
292 WATCHPOINT_ASSERT(0);
293 }
294
295+ unlikely ( rc != MEMCACHED_SUCCESS) ptr->root->last_disconnected_server = ptr;
296+
297 LIBMEMCACHED_MEMCACHED_CONNECT_END();
298
299 return rc;
300
301=== modified file 'libmemcached/memcached_hosts.c'
302--- libmemcached/memcached_hosts.c 2009-07-18 17:11:59 +0000
303+++ libmemcached/memcached_hosts.c 2009-10-10 20:30:24 +0000
304@@ -2,7 +2,7 @@
305 #include <math.h>
306
307 /* Protoypes (static) */
308-static memcached_return server_add(memcached_st *ptr, const char *hostname,
309+static memcached_return server_add(memcached_st *ptr, const char *hostname,
310 unsigned int port,
311 uint32_t weight,
312 memcached_connection type);
313@@ -36,7 +36,7 @@
314
315 memcached_return run_distribution(memcached_st *ptr)
316 {
317- switch (ptr->distribution)
318+ switch (ptr->distribution)
319 {
320 case MEMCACHED_DISTRIBUTION_CONSISTENT:
321 case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
322@@ -51,6 +51,8 @@
323 WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
324 }
325
326+ ptr->last_disconnected_server = NULL;
327+
328 return MEMCACHED_SUCCESS;
329 }
330
331@@ -77,7 +79,7 @@
332 static uint32_t ketama_server_hash(const char *key, unsigned int key_length, int alignment)
333 {
334 unsigned char results[16];
335-
336+
337 md5_signature((unsigned char*)key, key_length, results);
338 return ((uint32_t) (results[3 + alignment * 4] & 0xFF) << 24)
339 | ((uint32_t) (results[2 + alignment * 4] & 0xFF) << 16)
340@@ -155,7 +157,7 @@
341 {
342 memcached_continuum_item_st *new_ptr;
343
344- new_ptr= ptr->call_realloc(ptr, ptr->continuum,
345+ new_ptr= ptr->call_realloc(ptr, ptr->continuum,
346 sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server);
347
348 if (new_ptr == 0)
349@@ -165,9 +167,9 @@
350 ptr->continuum_count= live_servers + MEMCACHED_CONTINUUM_ADDITION;
351 }
352
353- if (is_ketama_weighted)
354+ if (is_ketama_weighted)
355 {
356- for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
357+ for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
358 {
359 if (list[host_index].weight == 0)
360 {
361@@ -178,27 +180,27 @@
362 }
363 }
364
365- for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
366+ for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
367 {
368 if (is_auto_ejecting && list[host_index].next_retry > now.tv_sec)
369 continue;
370
371- if (is_ketama_weighted)
372+ if (is_ketama_weighted)
373 {
374 float pct = (float)list[host_index].weight / (float)total_weight;
375 pointer_per_server= (uint32_t) ((floorf((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
376 pointer_per_hash= 4;
377 #ifdef DEBUG
378- printf("ketama_weighted:%s|%d|%llu|%u\n",
379- list[host_index].hostname,
380- list[host_index].port,
381- (unsigned long long)list[host_index].weight,
382+ printf("ketama_weighted:%s|%d|%llu|%u\n",
383+ list[host_index].hostname,
384+ list[host_index].port,
385+ (unsigned long long)list[host_index].weight,
386 pointer_per_server);
387 #endif
388 }
389 for (pointer_index= 1;
390 pointer_index <= pointer_per_server / pointer_per_hash;
391- ++pointer_index)
392+ ++pointer_index)
393 {
394 char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
395 size_t sort_host_length;
396@@ -214,7 +216,7 @@
397 else
398 {
399 sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
400- "%s:%d-%d",
401+ "%s:%d-%d",
402 list[host_index].hostname,
403 list[host_index].port, pointer_index - 1);
404 }
405@@ -247,7 +249,7 @@
406 qsort(ptr->continuum, ptr->continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
407
408 #ifdef DEBUG
409- for (pointer_index= 0; ptr->number_of_hosts && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
410+ for (pointer_index= 0; ptr->number_of_hosts && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
411 {
412 WATCHPOINT_ASSERT(ptr->continuum[pointer_index].value <= ptr->continuum[pointer_index + 1].value);
413 }
414@@ -267,7 +269,7 @@
415 return MEMCACHED_SUCCESS;
416
417 count= list[0].count;
418- new_host_list= ptr->call_realloc(ptr, ptr->hosts,
419+ new_host_list= ptr->call_realloc(ptr, ptr->hosts,
420 sizeof(memcached_server_st) * (count + ptr->number_of_hosts));
421
422 if (!new_host_list)
423@@ -285,7 +287,7 @@
424 WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
425 memcached_server_create(ptr, &ptr->hosts[ptr->number_of_hosts]);
426 /* TODO check return type */
427- (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname,
428+ (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname,
429 list[x].port, list[x].weight, list[x].type);
430 ptr->number_of_hosts++;
431 }
432@@ -294,14 +296,14 @@
433 return run_distribution(ptr);
434 }
435
436-memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
437+memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
438 const char *filename)
439 {
440 return memcached_server_add_unix_socket_with_weight(ptr, filename, 0);
441 }
442
443-memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
444- const char *filename,
445+memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
446+ const char *filename,
447 uint32_t weight)
448 {
449 if (!filename)
450@@ -310,41 +312,41 @@
451 return server_add(ptr, filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET);
452 }
453
454-memcached_return memcached_server_add_udp(memcached_st *ptr,
455+memcached_return memcached_server_add_udp(memcached_st *ptr,
456 const char *hostname,
457 unsigned int port)
458 {
459 return memcached_server_add_udp_with_weight(ptr, hostname, port, 0);
460 }
461
462-memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
463+memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
464 const char *hostname,
465 unsigned int port,
466 uint32_t weight)
467 {
468 if (!port)
469- port= MEMCACHED_DEFAULT_PORT;
470+ port= MEMCACHED_DEFAULT_PORT;
471
472 if (!hostname)
473- hostname= "localhost";
474+ hostname= "localhost";
475
476 return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP);
477 }
478
479-memcached_return memcached_server_add(memcached_st *ptr,
480- const char *hostname,
481+memcached_return memcached_server_add(memcached_st *ptr,
482+ const char *hostname,
483 unsigned int port)
484 {
485 return memcached_server_add_with_weight(ptr, hostname, port, 0);
486 }
487
488-memcached_return memcached_server_add_with_weight(memcached_st *ptr,
489- const char *hostname,
490+memcached_return memcached_server_add_with_weight(memcached_st *ptr,
491+ const char *hostname,
492 unsigned int port,
493 uint32_t weight)
494 {
495 if (!port)
496- port= MEMCACHED_DEFAULT_PORT;
497+ port= MEMCACHED_DEFAULT_PORT;
498
499 if (!hostname)
500 hostname= "localhost";
501@@ -352,7 +354,7 @@
502 return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_TCP);
503 }
504
505-static memcached_return server_add(memcached_st *ptr, const char *hostname,
506+static memcached_return server_add(memcached_st *ptr, const char *hostname,
507 unsigned int port,
508 uint32_t weight,
509 memcached_connection type)
510@@ -362,8 +364,8 @@
511 if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP)
512 || ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) )
513 return MEMCACHED_INVALID_HOST_PROTOCOL;
514-
515- new_host_list= ptr->call_realloc(ptr, ptr->hosts,
516+
517+ new_host_list= ptr->call_realloc(ptr, ptr->hosts,
518 sizeof(memcached_server_st) * (ptr->number_of_hosts+1));
519
520 if (new_host_list == NULL)
521@@ -385,18 +387,18 @@
522 memcached_st *ptr= st_ptr->root;
523 memcached_server_st *list= ptr->hosts;
524
525- for (x= 0, host_index= 0; x < ptr->number_of_hosts; x++)
526+ for (x= 0, host_index= 0; x < ptr->number_of_hosts; x++)
527 {
528- if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port)
529+ if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port)
530 {
531 if (host_index != x)
532 memcpy(list+host_index, list+x, sizeof(memcached_server_st));
533 host_index++;
534- }
535+ }
536 }
537 ptr->number_of_hosts= host_index;
538
539- if (st_ptr->address_info)
540+ if (st_ptr->address_info)
541 {
542 freeaddrinfo(st_ptr->address_info);
543 st_ptr->address_info= NULL;
544@@ -406,16 +408,16 @@
545 return MEMCACHED_SUCCESS;
546 }
547
548-memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
549+memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
550 const char *hostname, unsigned int port,
551 memcached_return *error)
552 {
553 return memcached_server_list_append_with_weight(ptr, hostname, port, 0, error);
554 }
555
556-memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
557+memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
558 const char *hostname, unsigned int port,
559- uint32_t weight,
560+ uint32_t weight,
561 memcached_return *error)
562 {
563 unsigned int count;
564@@ -425,14 +427,14 @@
565 return NULL;
566
567 if (!port)
568- port= MEMCACHED_DEFAULT_PORT;
569+ port= MEMCACHED_DEFAULT_PORT;
570
571 /* Increment count for hosts */
572 count= 1;
573 if (ptr != NULL)
574 {
575 count+= ptr[0].count;
576- }
577+ }
578
579 new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count);
580 if (!new_host_list)
581
582=== modified file 'libmemcached/memcached_server.c'
583--- libmemcached/memcached_server.c 2009-07-15 10:09:06 +0000
584+++ libmemcached/memcached_server.c 2009-10-10 20:30:24 +0000
585@@ -16,14 +16,14 @@
586 }
587 else
588 memset(ptr, 0, sizeof(memcached_server_st));
589-
590+
591 ptr->root= memc;
592
593 return ptr;
594 }
595
596-memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
597- const char *hostname, unsigned int port,
598+memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
599+ const char *hostname, unsigned int port,
600 uint32_t weight, memcached_connection type)
601 {
602 host= memcached_server_create(memc, host);
603@@ -76,7 +76,7 @@
604 if (ptr == NULL)
605 return NULL;
606
607- rv = memcached_server_create_with(ptr->root, clone,
608+ rv = memcached_server_create_with(ptr->root, clone,
609 ptr->hostname, ptr->port, ptr->weight,
610 ptr->type);
611 if (rv != NULL)
612@@ -90,7 +90,7 @@
613
614 }
615
616-memcached_return memcached_server_cursor(memcached_st *ptr,
617+memcached_return memcached_server_cursor(memcached_st *ptr,
618 memcached_server_function *callback,
619 void *context,
620 unsigned int number_of_callbacks)
621@@ -119,7 +119,7 @@
622 {
623 uint32_t server_key;
624
625- *error= memcached_validate_key_length(key_length,
626+ *error= memcached_validate_key_length(key_length,
627 ptr->flags & MEM_BINARY_PROTOCOL);
628 unlikely (*error != MEMCACHED_SUCCESS)
629 return NULL;
630@@ -146,7 +146,7 @@
631 {
632 if (ptr)
633 return ptr->cached_server_error;
634- else
635+ else
636 return NULL;
637 }
638
639@@ -154,3 +154,8 @@
640 {
641 ptr->cached_server_error[0]= 0;
642 }
643+
644+memcached_server_st *memcached_server_get_last_disconnect(memcached_st *ptr)
645+{
646+ return ptr->last_disconnected_server;
647+}
648
649=== modified file 'libmemcached/memcached_server.h'
650--- libmemcached/memcached_server.h 2009-09-17 19:14:07 +0000
651+++ libmemcached/memcached_server.h 2009-10-10 20:30:24 +0000
652@@ -49,13 +49,13 @@
653 #define memcached_server_response_count(A) (A)->cursor_active
654
655 LIBMEMCACHED_API
656-memcached_return memcached_server_cursor(memcached_st *ptr,
657+memcached_return memcached_server_cursor(memcached_st *ptr,
658 memcached_server_function *callback,
659 void *context,
660 unsigned int number_of_callbacks);
661
662 LIBMEMCACHED_API
663-memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key,
664+memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key,
665 size_t key_length, memcached_return *error);
666
667 LIBMEMCACHED_API
668@@ -71,8 +71,8 @@
669 memcached_server_st *memcached_server_create(memcached_st *memc, memcached_server_st *ptr);
670
671 LIBMEMCACHED_API
672-memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
673- const char *hostname, unsigned int port,
674+memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
675+ const char *hostname, unsigned int port,
676 uint32_t weight, memcached_connection type);
677
678 LIBMEMCACHED_API
679@@ -86,6 +86,9 @@
680 LIBMEMCACHED_API
681 memcached_return memcached_server_remove(memcached_server_st *st_ptr);
682
683+LIBMEMCACHED_API
684+memcached_server_st *memcached_server_get_last_disconnect(memcached_st *ptr);
685+
686 #ifdef __cplusplus
687 }
688 #endif
689
690=== modified file 'tests/function.c'
691--- tests/function.c 2009-10-09 17:41:13 +0000
692+++ tests/function.c 2009-10-10 20:30:24 +0000
693@@ -4732,6 +4732,60 @@
694 return TEST_SUCCESS;
695 }
696
697+
698+
699+/* Test memcached_server_get_last_disconnect
700+ * For a working server set, shall be NULL
701+ * For a set of non existing server, shall not be NULL
702+ */
703+static test_return_t test_get_last_disconnect(memcached_st *memc)
704+{
705+ memcached_return rc;
706+ memcached_server_st *disconnected_server;
707+
708+ /* With the working set of server */
709+ const char *key= "marmotte";
710+ const char *value= "milka";
711+
712+ rc= memcached_set(memc, key, strlen(key),
713+ value, strlen(value),
714+ (time_t)0, (uint32_t)0);
715+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
716+
717+ disconnected_server = memcached_server_get_last_disconnect(memc);
718+ assert(disconnected_server == NULL);
719+
720+ /* With a non existing server */
721+ memcached_st *mine;
722+ memcached_server_st *servers;
723+
724+ const char *server_list= "localhost:9";
725+
726+ servers= memcached_servers_parse(server_list);
727+ assert(servers);
728+ mine= memcached_create(NULL);
729+ rc= memcached_server_push(mine, servers);
730+ assert(rc == MEMCACHED_SUCCESS);
731+ memcached_server_list_free(servers);
732+ assert(mine);
733+
734+ rc= memcached_set(mine, key, strlen(key),
735+ value, strlen(value),
736+ (time_t)0, (uint32_t)0);
737+ assert(rc != MEMCACHED_SUCCESS);
738+
739+ disconnected_server = memcached_server_get_last_disconnect(mine);
740+ assert(disconnected_server != NULL);
741+ assert(disconnected_server->port == 9);
742+ assert(strncmp(disconnected_server->hostname,"localhost",9) == 0);
743+
744+ memcached_quit(mine);
745+ memcached_free(mine);
746+
747+ return TEST_SUCCESS;
748+}
749+
750+
751 test_st udp_setup_server_tests[] ={
752 {"set_udp_behavior_test", 0, set_udp_behavior_test},
753 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
754@@ -4811,6 +4865,7 @@
755 #ifdef HAVE_LIBMEMCACHEDUTIL
756 {"connectionpool", 1, connection_pool_test },
757 #endif
758+ {"test_get_last_disconnect", 1, test_get_last_disconnect},
759 {0, 0, 0}
760 };
761

Subscribers

People subscribed via source and target branches

to all changes: