Merge in build trunk.
[awesomized/libmemcached] / libtest / memcached.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * libtest
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 3 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22
23 #include <libtest/common.h>
24
25 #include <libmemcached-1.0/memcached.h>
26 #include <libmemcachedutil-1.0/util.h>
27
28 using namespace libtest;
29
30 #include <cassert>
31 #include <cerrno>
32 #include <cstdio>
33 #include <cstdlib>
34 #include <cstring>
35 #include <iostream>
36 #include <signal.h>
37 #include <sys/types.h>
38 #include <sys/wait.h>
39 #include <unistd.h>
40
41 #include <libtest/server.h>
42 #include <libtest/wait.h>
43
44 #include <libtest/memcached.h>
45
46 #ifndef __INTEL_COMPILER
47 #pragma GCC diagnostic ignored "-Wold-style-cast"
48 #endif
49
50 using namespace libtest;
51
52 class Memcached : public libtest::Server
53 {
54 std::string _username;
55 std::string _password;
56
57 public:
58 Memcached(const std::string& host_arg, const in_port_t port_arg, const bool is_socket_arg, const std::string& username_arg, const std::string& password_arg) :
59 libtest::Server(host_arg, port_arg, is_socket_arg),
60 _username(username_arg),
61 _password(password_arg)
62 { }
63
64 Memcached(const std::string& host_arg, const in_port_t port_arg, const bool is_socket_arg) :
65 libtest::Server(host_arg, port_arg, is_socket_arg)
66 {
67 set_pid_file();
68 }
69
70 virtual const char *sasl() const
71 {
72 return NULL;
73 }
74
75 const std::string& password() const
76 {
77 return _password;
78 }
79
80 const std::string& username() const
81 {
82 return _username;
83 }
84
85 pid_t get_pid(bool error_is_ok)
86 {
87 // Memcached is slow to start, so we need to do this
88 if (not pid_file().empty())
89 {
90 if (error_is_ok and not wait_for_pidfile())
91 {
92 Error << "Pidfile was not found:" << pid_file();
93 return -1;
94 }
95 }
96
97 pid_t local_pid;
98 memcached_return_t rc= MEMCACHED_SUCCESS;
99 if (has_socket())
100 {
101 if (socket().empty())
102 {
103 return -1;
104 }
105
106 local_pid= libmemcached_util_getpid(socket().c_str(), port(), &rc);
107 }
108 else
109 {
110 local_pid= libmemcached_util_getpid(hostname().c_str(), port(), &rc);
111 }
112
113 if (error_is_ok and ((memcached_failed(rc) or not is_pid_valid(local_pid))))
114 {
115 Error << "libmemcached_util_getpid(" << memcached_strerror(NULL, rc) << ") pid: " << local_pid << " for:" << *this;
116 }
117
118 return local_pid;
119 }
120
121 bool ping()
122 {
123 // Memcached is slow to start, so we need to do this
124 if (not pid_file().empty())
125 {
126 if (not wait_for_pidfile())
127 {
128 Error << "Pidfile was not found:" << pid_file();
129 return -1;
130 }
131 }
132
133 memcached_return_t rc;
134 bool ret;
135
136 if (has_socket())
137 {
138 ret= libmemcached_util_ping(socket().c_str(), 0, &rc);
139 }
140 else
141 {
142 ret= libmemcached_util_ping(hostname().c_str(), port(), &rc);
143 }
144
145 if (memcached_failed(rc) or not ret)
146 {
147 Error << "libmemcached_util_ping(" << hostname() << ", " << port() << ") error: " << memcached_strerror(NULL, rc);
148 }
149
150 return ret;
151 }
152
153 const char *name()
154 {
155 return "memcached";
156 };
157
158 const char *executable()
159 {
160 return MEMCACHED_BINARY;
161 }
162
163 const char *pid_file_option()
164 {
165 return "-P ";
166 }
167
168 const char *socket_file_option() const
169 {
170 return "-s ";
171 }
172
173 const char *daemon_file_option()
174 {
175 return "-d";
176 }
177
178 const char *log_file_option()
179 {
180 return NULL;
181 }
182
183 const char *port_option()
184 {
185 return "-p ";
186 }
187
188 bool is_libtool()
189 {
190 return false;
191 }
192
193 bool broken_socket_cleanup()
194 {
195 return true;
196 }
197
198 // Memcached's pidfile is broken
199 bool broken_pid_file()
200 {
201 return true;
202 }
203
204 bool build(int argc, const char *argv[]);
205 };
206
207 class MemcachedSaSL : public Memcached
208 {
209 public:
210 MemcachedSaSL(const std::string& host_arg, const in_port_t port_arg, const bool is_socket_arg, const std::string& username_arg, const std::string &password_arg) :
211 Memcached(host_arg, port_arg, is_socket_arg, username_arg, password_arg)
212 { }
213
214 const char *name()
215 {
216 return "memcached-sasl";
217 };
218
219 const char *sasl() const
220 {
221 return " -S -B binary ";
222 }
223
224 const char *executable()
225 {
226 return MEMCACHED_SASL_BINARY;
227 }
228
229 pid_t get_pid(bool error_is_ok)
230 {
231 // Memcached is slow to start, so we need to do this
232 if (not pid_file().empty())
233 {
234 if (error_is_ok and not wait_for_pidfile())
235 {
236 Error << "Pidfile was not found:" << pid_file();
237 return -1;
238 }
239 }
240
241 pid_t local_pid;
242 memcached_return_t rc;
243 if (has_socket())
244 {
245 local_pid= libmemcached_util_getpid2(socket().c_str(), 0, username().c_str(), password().c_str(), &rc);
246 }
247 else
248 {
249 local_pid= libmemcached_util_getpid2(hostname().c_str(), port(), username().c_str(), password().c_str(), &rc);
250 }
251
252 if (error_is_ok and ((memcached_failed(rc) or not is_pid_valid(local_pid))))
253 {
254 Error << "libmemcached_util_getpid2(" << memcached_strerror(NULL, rc) << ") username: " << username() << " password: " << password() << " pid: " << local_pid << " for:" << *this;
255 }
256
257 return local_pid;
258 }
259
260 bool ping()
261 {
262 // Memcached is slow to start, so we need to do this
263 if (not pid_file().empty())
264 {
265 if (not wait_for_pidfile())
266 {
267 Error << "Pidfile was not found:" << pid_file();
268 return -1;
269 }
270 }
271
272 memcached_return_t rc;
273 bool ret;
274
275 if (has_socket())
276 {
277 ret= libmemcached_util_ping2(socket().c_str(), 0, username().c_str(), password().c_str(), &rc);
278 }
279 else
280 {
281 ret= libmemcached_util_ping2(hostname().c_str(), port(), username().c_str(), password().c_str(), &rc);
282 }
283
284 if (memcached_failed(rc) or not ret)
285 {
286 Error << "libmemcached_util_ping2(" << hostname() << ", " << port() << ", " << username() << ", " << password() << ") error: " << memcached_strerror(NULL, rc);
287 }
288
289 return ret;
290 }
291
292 };
293
294
295 #include <sstream>
296
297 bool Memcached::build(int argc, const char *argv[])
298 {
299 std::stringstream arg_buffer;
300
301 if (getuid() == 0 or geteuid() == 0)
302 {
303 arg_buffer << " -u root ";
304 }
305
306 arg_buffer << " -l localhost ";
307 arg_buffer << " -m 128 ";
308 arg_buffer << " -M ";
309
310 if (sasl())
311 {
312 arg_buffer << sasl();
313 }
314
315 for (int x= 1 ; x < argc ; x++)
316 {
317 arg_buffer << " " << argv[x] << " ";
318 }
319
320 set_extra_args(arg_buffer.str());
321
322 return true;
323 }
324
325 namespace libtest {
326
327 libtest::Server *build_memcached(const std::string& hostname, const in_port_t try_port)
328 {
329 return new Memcached(hostname, try_port, false);
330 }
331
332 libtest::Server *build_memcached_socket(const std::string& socket_file, const in_port_t try_port)
333 {
334 return new Memcached(socket_file, try_port, true);
335 }
336
337
338 libtest::Server *build_memcached_sasl(const std::string& hostname, const in_port_t try_port, const std::string& username, const std::string &password)
339 {
340 if (username.empty())
341 {
342 return new MemcachedSaSL(hostname, try_port, false, "memcached", "memcached");
343 }
344
345 return new MemcachedSaSL(hostname, try_port, false, username, password);
346 }
347
348 libtest::Server *build_memcached_sasl_socket(const std::string& socket_file, const in_port_t try_port, const std::string& username, const std::string &password)
349 {
350 if (username.empty())
351 {
352 return new MemcachedSaSL(socket_file, try_port, true, "memcached", "memcached");
353 }
354
355 return new MemcachedSaSL(socket_file, try_port, true, username, password);
356 }
357
358 }
359