Updating for 1.0.2 release
[awesomized/libmemcached] / libmemcached / fetch.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker 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
40 char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length,
41 size_t *value_length,
42 uint32_t *flags,
43 memcached_return_t *error)
44 {
45 memcached_result_st *result_buffer= &ptr->result;
46 memcached_return_t unused;
47 if (not error)
48 error= &unused;
49
50
51 unlikely (ptr->flags.use_udp)
52 {
53 if (value_length)
54 *value_length= 0;
55
56 if (key_length)
57 *key_length= 0;
58
59 if (flags)
60 *flags= 0;
61
62 if (key)
63 *key= 0;
64
65 *error= MEMCACHED_NOT_SUPPORTED;
66 return NULL;
67 }
68
69 result_buffer= memcached_fetch_result(ptr, result_buffer, error);
70 if (result_buffer == NULL or memcached_failed(*error))
71 {
72 WATCHPOINT_ASSERT(result_buffer == NULL);
73 if (value_length)
74 *value_length= 0;
75
76 if (key_length)
77 *key_length= 0;
78
79 if (flags)
80 *flags= 0;
81
82 if (key)
83 *key= 0;
84
85 return NULL;
86 }
87
88 if (value_length)
89 {
90 *value_length= memcached_string_length(&result_buffer->value);
91 }
92
93 if (key)
94 {
95 if (result_buffer->key_length > MEMCACHED_MAX_KEY)
96 {
97 *error= MEMCACHED_KEY_TOO_BIG;
98 if (value_length)
99 *value_length= 0;
100
101 if (key_length)
102 *key_length= 0;
103
104 if (flags)
105 *flags= 0;
106
107 if (key)
108 *key= 0;
109
110 return NULL;
111 }
112 strncpy(key, result_buffer->item_key, result_buffer->key_length); // For the binary protocol we will cut off the key :(
113 if (key_length)
114 *key_length= result_buffer->key_length;
115 }
116
117 if (flags)
118 *flags= result_buffer->item_flags;
119
120 return memcached_string_take_value(&result_buffer->value);
121 }
122
123 memcached_result_st *memcached_fetch_result(memcached_st *ptr,
124 memcached_result_st *result,
125 memcached_return_t *error)
126 {
127 memcached_return_t unused;
128 if (not error)
129 error= &unused;
130
131 if (not ptr)
132 {
133 *error= MEMCACHED_INVALID_ARGUMENTS;
134 return NULL;
135 }
136
137 if (ptr->flags.use_udp)
138 {
139 *error= MEMCACHED_NOT_SUPPORTED;
140 return NULL;
141 }
142
143 if (not result)
144 {
145 // If we have already initialized (ie it is in use) our internal, we
146 // create one.
147 if (memcached_is_initialized(&ptr->result))
148 {
149 if (not (result= memcached_result_create(ptr, NULL)))
150 {
151 *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
152 return NULL;
153 }
154 }
155 else
156 {
157 result= memcached_result_create(ptr, &ptr->result);
158 }
159 }
160
161 *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
162 memcached_server_st *server;
163 while ((server= memcached_io_get_readable_server(ptr)))
164 {
165 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
166 *error= memcached_response(server, buffer, sizeof(buffer), result);
167
168 if (*error == MEMCACHED_IN_PROGRESS)
169 {
170 continue;
171 }
172 else if (*error == MEMCACHED_SUCCESS)
173 {
174 result->count++;
175 return result;
176 }
177 else if (*error == MEMCACHED_END)
178 {
179 memcached_server_response_reset(server);
180 }
181 else if (*error != MEMCACHED_NOTFOUND)
182 {
183 break;
184 }
185 }
186
187 if (*error == MEMCACHED_NOTFOUND and result->count)
188 {
189 *error= MEMCACHED_END;
190 }
191 else if (*error == MEMCACHED_MAXIMUM_RETURN and result->count)
192 {
193 *error= MEMCACHED_END;
194 }
195 else if (*error == MEMCACHED_MAXIMUM_RETURN) // while() loop was never entered
196 {
197 *error= MEMCACHED_NOTFOUND;
198 }
199 else if (*error == MEMCACHED_SUCCESS)
200 {
201 *error= MEMCACHED_END;
202 }
203 else if (result->count == 0)
204 {
205 *error= MEMCACHED_NOTFOUND;
206 }
207
208 /* We have completed reading data */
209 if (memcached_is_allocated(result))
210 {
211 memcached_result_free(result);
212 }
213 else
214 {
215 result->count= 0;
216 memcached_string_reset(&result->value);
217 }
218
219 return NULL;
220 }
221
222 memcached_return_t memcached_fetch_execute(memcached_st *ptr,
223 memcached_execute_fn *callback,
224 void *context,
225 uint32_t number_of_callbacks)
226 {
227 memcached_result_st *result= &ptr->result;
228 memcached_return_t rc;
229 bool some_errors= false;
230
231 while ((result= memcached_fetch_result(ptr, result, &rc)))
232 {
233 if (memcached_failed(rc) and rc == MEMCACHED_NOTFOUND)
234 {
235 continue;
236 }
237 else if (memcached_failed(rc))
238 {
239 memcached_set_error(*ptr, rc, MEMCACHED_AT);
240 some_errors= true;
241 continue;
242 }
243
244 for (uint32_t x= 0; x < number_of_callbacks; x++)
245 {
246 memcached_return_t ret= (*callback[x])(ptr, result, context);
247 if (memcached_failed(ret))
248 {
249 some_errors= true;
250 memcached_set_error(*ptr, ret, MEMCACHED_AT);
251 break;
252 }
253 }
254 }
255
256 if (some_errors)
257 {
258 return MEMCACHED_SOME_ERRORS;
259 }
260
261 // If we were able to run all keys without issue we return
262 // MEMCACHED_SUCCESS
263 if (memcached_success(rc))
264 {
265 return MEMCACHED_SUCCESS;
266 }
267
268 return rc;
269 }