X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Fserver.h;h=a41e621bb1f491cccf804d334493b360c53e4409;hb=25efe3485198149616820ab4e52d2f18f0abe5a7;hp=c209881e3de25c3cf2b23ab97b87b44012de5235;hpb=7abcaebdc4c3dd11b779eaef58a7371fb82ae888;p=m6w6%2Flibmemcached

diff --git a/libtest/server.h b/libtest/server.h
index c209881e..a41e621b 100644
--- a/libtest/server.h
+++ b/libtest/server.h
@@ -1,46 +1,187 @@
-/*
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Data Differential YATL (i.e. libtest)  library
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Use and distribution licensed under the BSD license.  See
- * the COPYING file in the parent directory for full text.
  */
 
 #pragma once
 
+#include <libtest/cmdline.h>
+
+#include <cassert>
+#include <cstdio>
 #include <cstring>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <string>
 #include <unistd.h>
+#include <vector>
+
+namespace libtest {
 
-#define SERVERS_TO_CREATE 5
+struct Server {
+private:
+  typedef std::vector< std::pair<std::string, std::string> > Options;
 
-struct server_st {
 private:
-  bool _used;
-  pid_t _pid;
+  uint64_t _magic;
+  bool _is_socket;
+  std::string _socket;
+  std::string _sasl;
+  std::string _pid_file;
+  std::string _log_file;
+  std::string _base_command; // executable command which include libtool, valgrind, gdb, etc
+  std::string _running; // Current string being used for system()
+
+protected:
   in_port_t _port;
-  char pid_file[FILENAME_MAX]; // Did we start it, or was it just sitting there?
+  std::string _hostname;
+  std::string _extra_args;
+
 public:
+  Server(const std::string& hostname, const in_port_t port_arg,
+         const std::string& executable, const bool _is_libtool,
+         const bool is_socket_arg= false);
 
-  char hostname[NI_MAXHOST];
+  virtual ~Server();
 
-  server_st() :
-    _used(false),
-    _pid(-1),
-    _port(0)
+  virtual const char *name()= 0;
+  virtual bool is_libtool()= 0;
+
+  virtual bool has_socket_file_option() const
   {
-    pid_file[0]= 0;
-    strncpy(hostname, "localhost", sizeof(hostname));
+    return false;
   }
 
-  void set_port(in_port_t arg)
+  virtual void socket_file_option(Application& app, const std::string& socket_arg)
   {
-    _port= arg;
+    if (socket_arg.empty() == false)
+    {
+      std::string buffer("--socket=");
+      buffer+= socket_arg;
+      app.add_option(buffer);
+    }
   }
 
+  virtual bool has_log_file_option() const
+  {
+    return false;
+  }
+
+  virtual void log_file_option(Application& app, const std::string& arg)
+  {
+    if (arg.empty() == false)
+    {
+      std::string buffer("--log-file=");
+      buffer+= arg;
+      app.add_option(buffer);
+    }
+  }
+
+  virtual void pid_file_option(Application& app, const std::string& arg)
+  {
+    if (arg.empty() == false)
+    {
+      std::string buffer("--pid-file=");
+      buffer+= arg;
+      app.add_option(buffer);
+    }
+  }
+
+  virtual bool has_port_option() const
+  {
+    return false;
+  }
+
+  virtual void port_option(Application& app, in_port_t arg)
+  {
+    if (arg > 0)
+    {
+      char buffer[1024];
+      snprintf(buffer, sizeof(buffer), "--port=%d", int(arg));
+      app.add_option(buffer);
+    }
+  }
+
+  virtual bool broken_socket_cleanup()
+  {
+    return false;
+  }
+
+  virtual bool broken_pid_file()
+  {
+    return false;
+  }
+
+  const std::string& pid_file() const
+  {
+    return _pid_file;
+  }
+
+  const std::string& base_command() const
+  {
+    return _base_command;
+  }
+
+  const std::string& log_file() const
+  {
+    return _log_file;
+  }
+
+  const std::string& hostname() const
+  {
+    return _hostname;
+  }
+
+  const std::string& socket() const
+  {
+    return _socket;
+  }
+
+  bool has_socket() const
+  {
+    return _is_socket;
+  }
+
+  bool cycle();
+
+  virtual bool ping()= 0;
+
+  virtual bool build(size_t argc, const char *argv[])= 0;
+
+  void add_option(const std::string&);
+  void add_option(const std::string&, const std::string&);
+
   in_port_t port() const
   {
     return _port;
@@ -48,78 +189,86 @@ public:
 
   bool has_port() const
   {
-    return not _port == 0;
+    return (_port != 0);
   }
 
-  void set_used()
+  virtual bool has_syslog() const
   {
-    _used= true;
+    return false;
   }
 
-  void set_pid(pid_t arg)
+  // Reset a server if another process has killed the server
+  void reset()
+  {
+    _pid_file.clear();
+    _log_file.clear();
+  }
+
+  pid_t pid() const;
+
+  bool has_pid() const;
+
+  virtual bool has_pid_file() const
   {
-    _pid= arg;
+    return true;
   }
 
-  pid_t pid() const
+  const std::string& error()
   {
-    return _pid;
+    return _error;
   }
 
-  bool is_used() const
+  void error(std::string arg)
   {
-    return _used;
+    _error= arg;
   }
 
-  ~server_st();
+  virtual bool wait_for_pidfile() const;
 
-  bool has_pid()
+  bool check_pid(pid_t pid_arg) const
   {
-    return _pid > 0;
+    return (pid_arg > 1);
   }
 
   bool is_socket() const
   {
-    return hostname[0] == '/';
+    return _hostname[0] == '/';
   }
 
-  void set_hostname(const char *arg)
+  const std::string running() const
   {
-    strncpy(hostname, arg, sizeof(hostname));
+    return _running;
   }
 
-  bool kill();
+  bool check();
 
-private:
-  void reset_pid();
-};
+  std::string log_and_pid();
 
-std::ostream& operator<<(std::ostream& output, const server_st &arg);
+  bool kill();
+  bool start();
+  bool command(libtest::Application& app);
+
+  bool validate();
 
-struct server_startup_st
-{
-  uint8_t count;
-  uint8_t udp;
-  std::string server_list;
-  server_st server[SERVERS_TO_CREATE];
+protected:
+  bool set_pid_file();
+  Options _options;
+  Application _app;
 
-  server_startup_st() :
-    count(SERVERS_TO_CREATE),
-    udp(0)
-  { }
+private:
+  bool is_helgrind() const;
+  bool is_valgrind() const;
+  bool is_debug() const;
+  bool set_log_file();
+  bool set_socket_file();
+  void reset_pid();
+  bool args(Application&);
 
-  ~server_startup_st()
-  { }
+  std::string _error;
 };
 
-#ifdef	__cplusplus
-extern "C" {
-#endif
+std::ostream& operator<<(std::ostream& output, const libtest::Server &arg);
 
+} // namespace libtest
 
-bool server_startup(server_startup_st *construct);
-void server_shutdown(server_startup_st *construct);
 
-#ifdef	__cplusplus
-}
-#endif