git.m6w6.name Git - m6w6/libmemcached/blob - 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/memcached.h>
  26 #include <libmemcached/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