X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=libtest%2Fserver.cc;h=c1d01c749e4d3353d32a63301904385448cd3dd1;hb=45c6b15d970aca4fa5619b2ba501c1b0f1d89006;hp=55713d45ced450d831bb71d971c98b6371156b02;hpb=7ba11a92a63df071ee3f848c980c8459dc184ebc;p=awesomized%2Flibmemcached

diff --git a/libtest/server.cc b/libtest/server.cc
index 55713d45..c1d01c74 100644
--- a/libtest/server.cc
+++ b/libtest/server.cc
@@ -81,7 +81,6 @@ Server::Server(const std::string& host_arg, const in_port_t port_arg,
                bool is_socket_arg) :
   _magic(MAGIC_MEMORY),
   _is_socket(is_socket_arg),
-  _pid(-1),
   _port(port_arg),
   _hostname(host_arg),
   _app(executable, _is_libtool)
@@ -90,22 +89,13 @@ Server::Server(const std::string& host_arg, const in_port_t port_arg,
 
 Server::~Server()
 {
-  if (has_pid() and not kill(_pid))
-  {
-    Error << "Unable to kill:" << *this;
-  }
-
-  Application::error_t ret;
-  if (Application::SUCCESS !=  (ret= _app.wait()))
-  {
-    Error << "Application::wait() " << _running << " " << ret << ": " << _app.stderr_result();
-  }
 }
 
 bool Server::check()
 {
   _app.slurp();
-  return _app.check();
+  _app.check();
+  return true;
 }
 
 bool Server::validate()
@@ -119,13 +109,12 @@ bool Server::cycle()
   uint32_t limit= 3;
 
   // Try to ping, and kill the server #limit number of times
-  pid_t current_pid;
   while (--limit and 
-         is_pid_valid(current_pid= get_pid()))
+         is_pid_valid(_app.pid()))
   {
-    if (kill(current_pid))
+    if (kill())
     {
-      Log << "Killed existing server," << *this << " with pid:" << current_pid;
+      Log << "Killed existing server," << *this;
       dream(0, 50000);
       continue;
     }
@@ -134,7 +123,7 @@ bool Server::cycle()
   // For whatever reason we could not kill it, and we reached limit
   if (limit == 0)
   {
-    Error << "Reached limit, could not kill server pid:" << current_pid;
+    Error << "Reached limit, could not kill server";
     return false;
   }
 
@@ -148,16 +137,16 @@ bool Server::wait_for_pidfile() const
   return wait.successful();
 }
 
+bool Server::has_pid() const
+{
+  return (_app.pid() > 1);
+}
+
+
 bool Server::start()
 {
   // If we find that we already have a pid then kill it.
-  if (has_pid() and kill(_pid) == false)
-  {
-    Error << "Could not kill() existing server during start() pid:" << _pid;
-    return false;
-  }
-
-  if (has_pid() == false)
+  if (has_pid() == true)
   {
     fatal_message("has_pid() failed, programer error");
   }
@@ -170,7 +159,11 @@ bool Server::start()
   }
 #endif
 
-  if (args(_app) == false)
+  if (getenv("YATL_VALGRIND_SERVER"))
+  {
+    _app.use_valgrind();
+  }
+  else if (args(_app) == false)
   {
     Error << "Could not build command()";
     return false;
@@ -189,15 +182,24 @@ bool Server::start()
     dream(5, 50000);
   }
 
-  if (pid_file().empty() == false)
+  size_t repeat= 5;
+  while (--repeat)
   {
-    Wait wait(pid_file(), 8);
-
-    if (wait.successful() == false)
+    if (pid_file().empty() == false)
     {
-      libtest::fatal(LIBYATL_DEFAULT_PARAM,
-                     "Unable to open pidfile for: %s",
-                     _running.c_str());
+      Wait wait(pid_file(), 8);
+
+      if (wait.successful() == false)
+      {
+        if (_app.check())
+        {
+          continue;
+        }
+
+        throw libtest::fatal(LIBYATL_DEFAULT_PARAM,
+                             "Unable to open pidfile for: %s",
+                             _running.c_str());
+      }
     }
   }
 
@@ -227,27 +229,27 @@ bool Server::start()
   if (pinged == false)
   {
     // If we happen to have a pid file, lets try to kill it
-    if (pid_file().empty() == false)
+    if ((pid_file().empty() == false) and (access(pid_file().c_str(), R_OK) == 0))
     {
       if (kill_file(pid_file()) == false)
       {
-        fatal_message("Failed to kill off server after startup occurred, when pinging failed");
+        throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Failed to kill off server after startup occurred, when pinging failed: %s", pid_file().c_str());
       }
-      Error << "Failed to ping(), waited:" << this_wait 
-        << " server started, having pid_file. exec:" << _running 
-        << " error:" << _app.stderr_result();
+
+      throw libtest::fatal(LIBYATL_DEFAULT_PARAM, 
+                           "Failed to ping(), waited: %u server started, having pid_file. exec: %s error:%s",
+                           this_wait, _running.c_str(), _app.stderr_c_str()); 
     }
     else
     {
-      Error << "Failed to ping() server started. exec:" << _running;
+      throw libtest::fatal(LIBYATL_DEFAULT_PARAM,
+                           "Failed to ping() server started. exec: %s",
+                           _running.c_str());
     }
     _running.clear();
     return false;
   }
 
-  // A failing get_pid() at this point is considered an error
-  _pid= get_pid(true);
-
   return has_pid();
 }
 
@@ -255,12 +257,11 @@ void Server::reset_pid()
 {
   _running.clear();
   _pid_file.clear();
-  _pid= -1;
 }
 
-pid_t Server::pid()
+pid_t Server::pid() const
 {
-  return _pid;
+  return _app.pid();
 }
 
 void Server::add_option(const std::string& arg)
@@ -338,7 +339,7 @@ bool Server::set_log_file()
   int fd;
   if ((fd= mkstemp(file_buffer)) == -1)
   {
-    libtest::fatal(LIBYATL_DEFAULT_PARAM, "mkstemp() failed on %s with %s", file_buffer, strerror(errno));
+    throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "mkstemp() failed on %s with %s", file_buffer, strerror(errno));
   }
   close(fd);
 
@@ -351,7 +352,7 @@ bool Server::args(Application& app)
 {
 
   // Set a log file if it was requested (and we can)
-  if (has_log_file_option())
+  if (false and has_log_file_option())
   {
     set_log_file();
     log_file_option(app, _log_file);
@@ -402,10 +403,11 @@ bool Server::args(Application& app)
   return true;
 }
 
-bool Server::kill(pid_t pid_arg)
+bool Server::kill()
 {
-  if (check_pid(pid_arg) and kill_pid(pid_arg)) // If we kill it, reset
+  if (check_pid(_app.pid())) // If we kill it, reset
   {
+    _app.murder();
     if (broken_pid_file() and pid_file().empty() == false)
     {
       unlink(pid_file().c_str());