Merge in fixes for SASL.

[m6w6/libmemcached] / libtest / memcached.cc

diff --git a/libtest/memcached.cc b/libtest/memcached.cc
index 1344c61854acddb513591949f400d74827c9796f..3aba25430b20b35eabf0378dab5c3d659f45c096 100644 (file)
--- a/libtest/memcached.cc
+++ b/libtest/memcached.cc
@@ -51,10 +51,36 @@ using namespace libtest;
 
 class Memcached : public libtest::Server
 {
+  std::string _username;
+  std::string _password;
+
 public:
+  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) :
+    libtest::Server(host_arg, port_arg, is_socket_arg),
+    _username(username_arg),
+    _password(password_arg)
+  { }
+
   Memcached(const std::string& host_arg, const in_port_t port_arg, const bool is_socket_arg) :
     libtest::Server(host_arg, port_arg, is_socket_arg)
-  { }
+  {
+    set_pid_file();
+  }
+
+  virtual const char *sasl() const
+  {
+    return NULL;
+  }
+
+  const std::string& password() const
+  {
+    return _password;
+  }
+
+  const std::string& username() const
+  {
+    return _username;
+  }
 
   pid_t get_pid(bool error_is_ok)
   {
@@ -74,14 +100,28 @@ public:
     memcached_return_t rc;
     if (has_socket())
     {
-      local_pid= libmemcached_util_getpid(socket().c_str(), port(), &rc);
+      if (username().empty())
+      {
+        local_pid= libmemcached_util_getpid(socket().c_str(), 0, &rc);
+      }
+      else
+      {
+        local_pid= libmemcached_util_getpid2(socket().c_str(), 0, username().c_str(), password().c_str(), &rc);
+      }
     }
     else
     {
-      local_pid= libmemcached_util_getpid(hostname().c_str(), port(), &rc);
+      if (username().empty())
+      {
+        local_pid= libmemcached_util_getpid(hostname().c_str(), port(), &rc);
+      }
+      else
+      {
+        local_pid= libmemcached_util_getpid2(hostname().c_str(), port(), username().c_str(), password().c_str(), &rc);
+      }
     }
 
-    if (error_is_ok and ((memcached_failed(rc) or local_pid < 1)))
+    if (error_is_ok and ((memcached_failed(rc) or not is_pid_valid(local_pid))))
     {
       Error << "libmemcached_util_getpid(" << memcached_strerror(NULL, rc) << ") pid: " << local_pid << " for:" << *this;
     }
@@ -105,19 +145,42 @@ public:
 
     memcached_return_t rc;
     bool ret;
+
     if (has_socket())
     {
-      ret= libmemcached_util_ping(socket().c_str(), 0, &rc);
+      if (username().empty())
+      {
+        ret= libmemcached_util_ping(socket().c_str(), 0, &rc);
+      }
+      else
+      {
+        ret= libmemcached_util_ping2(socket().c_str(), 0, username().c_str(), password().c_str(), &rc);
+      }
     }
     else
     {
-      ret= libmemcached_util_ping(hostname().c_str(), port(), &rc);
+      if (username().empty())
+      {
+        ret= libmemcached_util_ping(hostname().c_str(), port(), &rc);
+      }
+      else
+      {
+        ret= libmemcached_util_ping2(hostname().c_str(), port(), username().c_str(), password().c_str(), &rc);
+      }
     }
 
     if (memcached_failed(rc) or not ret)
     {
-      Error << "libmemcached_util_ping(" << memcached_strerror(NULL, rc) << ")";
+      if (username().empty())
+      {
+        Error << "libmemcached_util_ping(" << hostname() << ", " << port() << ") error: " << memcached_strerror(NULL, rc);
+      }
+      else
+      {
+        Error << "libmemcached_util_ping2(" << hostname() << ", " << port() << ", " << username() << ", " << password() << ") error: " << memcached_strerror(NULL, rc);
+      }
     }
+
     return ret;
   }
 
@@ -175,6 +238,30 @@ public:
   bool build(int argc, const char *argv[]);
 };
 
+class MemcachedSaSL : public Memcached
+{
+public:
+  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) :
+    Memcached(host_arg, port_arg, is_socket_arg, username_arg, password_arg)
+  { }
+
+  const char *name()
+  {
+    return "memcached-sasl";
+  };
+
+  const char *sasl() const
+  {
+    return " -S -B binary ";
+  }
+
+  const char *executable()
+  {
+    return MEMCACHED_SASL_BINARY;
+  }
+
+};
+
 
 #include <sstream>
 
@@ -191,6 +278,11 @@ bool Memcached::build(int argc, const char *argv[])
   arg_buffer << " -m 128 ";
   arg_buffer << " -M ";
 
+  if (sasl())
+  {
+    arg_buffer << sasl();
+  }
+
   for (int x= 1 ; x < argc ; x++)
   {
     arg_buffer << " " << argv[x] << " ";
@@ -208,9 +300,20 @@ libtest::Server *build_memcached(const std::string& hostname, const in_port_t tr
   return new Memcached(hostname, try_port, false);
 }
 
-libtest::Server *build_memcached_socket(const std::string& hostname, const in_port_t try_port)
+libtest::Server *build_memcached_socket(const std::string& socket_file, const in_port_t try_port)
+{
+  return new Memcached(socket_file, try_port, true);
+}
+
+
+libtest::Server *build_memcached_sasl(const std::string& hostname, const in_port_t try_port, const std::string& username, const std::string &password)
+{
+  return new MemcachedSaSL(hostname, try_port, false,  username, password);
+}
+
+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)
 {
-  return new Memcached(hostname, try_port, true);
+  return new MemcachedSaSL(socket_file, try_port, true, username, password);
 }
 
 }