/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- * libtest
*
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Data Differential YATL (i.e. libtest) library
*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
+ * Copyright (C) 2012 Data Differential, http://datadifferential.com/
*
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
+ * 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.
*
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
using namespace libtest;
#include <cstdlib>
#include <cstring>
+#include <cerrno>
#include <fcntl.h>
#include <fstream>
#include <memory>
+#include <poll.h>
#include <spawn.h>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
+#include <unistd.h>
+
+#ifndef __USE_GNU
+static char **environ= NULL;
+#endif
extern "C" {
static int exited_successfully(int status)
_use_libtool(_use_libtool_arg),
_use_valgrind(false),
_use_gdb(false),
+ _use_ptrcheck(false),
+ _will_fail(false),
_argc(0),
_exectuble(arg),
+ stdin_fd(STDIN_FILENO),
+ stdout_fd(STDOUT_FILENO),
+ stderr_fd(STDERR_FILENO),
built_argv(NULL),
_pid(-1)
{
{
if (libtool() == NULL)
{
- throw "libtool requested, but know libtool was found";
+ fatal_message("libtool requested, but know libtool was found");
}
}
Application::~Application()
{
+ murder();
delete_argv();
}
posix_spawn_file_actions_t file_actions;
posix_spawn_file_actions_init(&file_actions);
- stdin_fd.dup_for_spawn(Application::Pipe::READ, file_actions, STDIN_FILENO);
- stdout_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDOUT_FILENO);
- stderr_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDERR_FILENO);
+ stdin_fd.dup_for_spawn(Application::Pipe::READ, file_actions);
+ stdout_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions);
+ stderr_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions);
+
+ posix_spawnattr_t spawnattr;
+ posix_spawnattr_init(&spawnattr);
+
+ sigset_t set;
+ sigemptyset(&set);
+ fatal_assert(posix_spawnattr_setsigmask(&spawnattr, &set) == 0);
create_argv(args);
const_cast<char *>(_exectuble_with_path.c_str()),
0};
- spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, NULL, argv, NULL);
+ spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, &spawnattr, argv, environ);
}
else
{
const_cast<char *>(gdb_run_file.c_str()),
const_cast<char *>(_exectuble_with_path.c_str()),
0};
- spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, NULL, argv, NULL);
+ spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, &spawnattr, argv, environ);
}
}
else
{
if (_use_libtool)
{
- spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL);
+ spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, &spawnattr, built_argv, NULL);
}
else
{
- spawn_ret= posix_spawnp(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL);
+ spawn_ret= posix_spawnp(&_pid, built_argv[0], &file_actions, &spawnattr, built_argv, NULL);
}
}
posix_spawn_file_actions_destroy(&file_actions);
+ posix_spawnattr_destroy(&spawnattr);
stdin_fd.close(Application::Pipe::READ);
stdout_fd.close(Application::Pipe::WRITE);
stderr_fd.close(Application::Pipe::WRITE);
- if (spawn_ret)
+ if (spawn_ret != 0)
{
- Error << print();
+ if (_will_fail == false)
+ {
+ Error << strerror(spawn_ret) << "(" << spawn_ret << ")";
+ }
+ _pid= -1;
return Application::INVALID;
}
return Application::SUCCESS;
}
-Application::error_t Application::wait()
+bool Application::check() const
{
- if (_pid == -1)
+ if (_pid > 1 and kill(_pid, 0) == 0)
{
- Error << "wait() got an invalid pid_t";
- return Application::INVALID;
+ return true;
}
+ return false;
+}
+
+void Application::murder()
+{
+ if (check())
{
- ssize_t read_length;
- char buffer[1024]= { 0 };
- bool bail= false;
- while (((read_length= ::read(stdout_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
+ int count= 5;
+ while ((count--) > 0 and check())
{
- if (read_length == -1)
+ int kill_ret= kill(_pid, SIGTERM);
+ if (kill_ret == 0)
{
- switch(errno)
+ int status= 0;
+ pid_t waitpid_ret;
+ if ((waitpid_ret= waitpid(_pid, &status, WNOHANG)) == -1)
{
- case EAGAIN:
- continue;
+ switch (errno)
+ {
+ case ECHILD:
+ case EINTR:
+ break;
+
+ default:
+ Error << "waitpid() failed after kill with error of " << strerror(errno);
+ break;
+ }
+ }
- default:
- Error << strerror(errno);
- bail= true;
+ if (waitpid_ret == 0)
+ {
+ libtest::dream(1, 0);
}
}
- _stdout_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
+ else
{
- _stdout_buffer.push_back(buffer[x]);
+ Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno);
+ continue;
}
- // @todo Suck up all output code here
+
+ break;
+ }
+
+ // If for whatever reason it lives, kill it hard
+ if (check())
+ {
+ (void)kill(_pid, SIGKILL);
}
}
+ slurp();
+}
+// false means that no data was returned
+bool Application::slurp()
+{
+ struct pollfd fds[2];
+ fds[0].fd= stdout_fd.fd();
+ fds[0].events= POLLRDNORM;
+ fds[0].revents= 0;
+ fds[1].fd= stderr_fd.fd();
+ fds[1].events= POLLRDNORM;
+ fds[1].revents= 0;
+
+ int active_fd;
+ if ((active_fd= poll(fds, 2, 0)) == -1)
{
- ssize_t read_length;
- char buffer[1024]= { 0 };
- bool bail= false;
- while (((read_length= ::read(stderr_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
+ int error;
+ switch ((error= errno))
{
- if (read_length == -1)
- {
- switch(errno)
- {
- case EAGAIN:
- continue;
+#ifdef TARGET_OS_LINUX
+ case ERESTART:
+#endif
+ case EINTR:
+ break;
- default:
- Error << strerror(errno);
- bail= true;
- }
- }
- _stderr_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
- {
- _stderr_buffer.push_back(buffer[x]);
- }
- // @todo Suck up all errput code here
+ case EFAULT:
+ case ENOMEM:
+ fatal_message(strerror(error));
+ break;
+
+ case EINVAL:
+ fatal_message("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid");
+ break;
+
+ default:
+ fatal_message(strerror(error));
+ break;
}
+
+ return false;
}
+ if (active_fd == 0)
+ {
+ return false;
+ }
+
+ bool data_was_read= false;
+ if (fds[0].revents & POLLRDNORM)
+ {
+ if (stdout_fd.read(_stdout_buffer) == true)
+ {
+ data_was_read= true;
+ }
+ }
+
+ if (fds[1].revents & POLLRDNORM)
+ {
+ if (stderr_fd.read(_stderr_buffer) == true)
+ {
+ data_was_read= true;
+ }
+ }
+
+ return data_was_read;
+}
+
+Application::error_t Application::wait(bool nohang)
+{
+ if (_pid == -1)
+ {
+ return Application::INVALID;
+ }
+
+ slurp();
+
error_t exit_code= FAILURE;
{
int status= 0;
pid_t waited_pid;
- if ((waited_pid= waitpid(_pid, &status, 0)) == -1)
+ if ((waited_pid= waitpid(_pid, &status, nohang ? WNOHANG : 0)) == -1)
+ {
+ switch (errno)
+ {
+ case ECHILD:
+ exit_code= Application::SUCCESS;
+ break;
+
+ case EINTR:
+ break;
+
+ default:
+ Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
+ break;
+ }
+ }
+ else if (waited_pid == 0)
{
- Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
+ exit_code= Application::SUCCESS;
}
else
{
}
}
+ slurp();
+
#if 0
if (exit_code == Application::INVALID)
{
return exit_code;
}
+void Application::add_long_option(const std::string& name, const std::string& option_value)
+{
+ std::string arg(name);
+ arg+= option_value;
+ _options.push_back(std::make_pair(arg, std::string()));
+}
+
void Application::add_option(const std::string& arg)
{
_options.push_back(std::make_pair(arg, std::string()));
_options.push_back(std::make_pair(name, value));
}
-Application::Pipe::Pipe()
+Application::Pipe::Pipe(int arg) :
+ _std_fd(arg)
+{
+ _pipe_fd[READ]= -1;
+ _pipe_fd[WRITE]= -1;
+ _open[READ]= false;
+ _open[WRITE]= false;
+}
+
+int Application::Pipe::Pipe::fd()
{
- _fd[0]= -1;
- _fd[1]= -1;
- _open[0]= false;
- _open[1]= false;
+ if (_std_fd == STDOUT_FILENO)
+ {
+ return _pipe_fd[READ];
+ }
+ else if (_std_fd == STDERR_FILENO)
+ {
+ return _pipe_fd[READ];
+ }
+
+ return _pipe_fd[WRITE]; // STDIN_FILENO
+}
+
+
+bool Application::Pipe::read(libtest::vchar_t& arg)
+{
+ fatal_assert(_std_fd == STDOUT_FILENO or _std_fd == STDERR_FILENO);
+
+ bool data_was_read= false;
+
+ ssize_t read_length;
+ char buffer[1024]= { 0 };
+ while ((read_length= ::read(_pipe_fd[READ], buffer, sizeof(buffer))))
+ {
+ if (read_length == -1)
+ {
+ switch(errno)
+ {
+ case EAGAIN:
+ break;
+
+ default:
+ Error << strerror(errno);
+ break;
+ }
+
+ break;
+ }
+
+ data_was_read= true;
+ arg.reserve(read_length +1);
+ for (size_t x= 0; x < read_length; x++)
+ {
+ arg.push_back(buffer[x]);
+ }
+ // @todo Suck up all errput code here
+ }
+
+ return data_was_read;
+}
+
+void Application::Pipe::nonblock()
+{
+ int ret;
+ if ((ret= fcntl(_pipe_fd[READ], F_GETFL, 0)) == -1)
+ {
+ Error << "fcntl(F_GETFL) " << strerror(errno);
+ throw strerror(errno);
+ }
+
+ if ((ret= fcntl(_pipe_fd[READ], F_SETFL, ret | O_NONBLOCK)) == -1)
+ {
+ Error << "fcntl(F_SETFL) " << strerror(errno);
+ throw strerror(errno);
+ }
}
void Application::Pipe::reset()
close(READ);
close(WRITE);
- int ret;
- if ((ret= pipe(_fd)) < 0)
+#if HAVE_PIPE2
+ if (pipe2(_pipe_fd, O_NONBLOCK) == -1)
+#else
+ if (pipe(_pipe_fd) == -1)
+#endif
{
- throw strerror(ret);
+ fatal_message(strerror(errno));
}
_open[0]= true;
_open[1]= true;
+ if (true)
{
- ret= fcntl(_fd[0], F_GETFL, 0);
- if (ret == -1)
- {
- Error << "fcntl(F_GETFL) " << strerror(ret);
- throw strerror(ret);
- }
+ nonblock();
+ cloexec();
+ }
+}
- ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK);
- if (ret == -1)
- {
- Error << "fcntl(F_SETFL) " << strerror(ret);
- throw strerror(ret);
- }
+void Application::Pipe::cloexec()
+{
+ int ret;
+ if ((ret= fcntl(_pipe_fd[WRITE], F_GETFD, 0)) == -1)
+ {
+ Error << "fcntl(F_GETFD) " << strerror(errno);
+ throw strerror(errno);
+ }
+
+ if ((ret= fcntl(_pipe_fd[WRITE], F_SETFD, ret | FD_CLOEXEC)) == -1)
+ {
+ Error << "fcntl(F_SETFD) " << strerror(errno);
+ throw strerror(errno);
}
}
close(WRITE);
}
-void Application::Pipe::dup_for_spawn(const close_t& arg, posix_spawn_file_actions_t& file_actions, const int newfildes)
+void Application::Pipe::dup_for_spawn(const close_t& arg, posix_spawn_file_actions_t& file_actions)
{
int type= int(arg);
int ret;
- if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _fd[type], newfildes )) < 0)
+ if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _pipe_fd[type], _std_fd )) < 0)
{
Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
- throw strerror(ret);
+ fatal_message(strerror(ret));
}
- if ((ret= posix_spawn_file_actions_addclose(&file_actions, _fd[type])) < 0)
+ if ((ret= posix_spawn_file_actions_addclose(&file_actions, _pipe_fd[type])) < 0)
{
Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
- throw strerror(ret);
+ fatal_message(strerror(ret));
}
}
if (_open[type])
{
int ret;
- if ((ret= ::close(_fd[type])) < 0)
+ if (::close(_pipe_fd[type]) == -1)
{
- Error << "close(" << strerror(ret) << ")";
+ Error << "close(" << strerror(errno) << ")";
}
_open[type]= false;
+ _pipe_fd[type]= -1;
}
}
void Application::create_argv(const char *args[])
{
- _argc= 2 +_use_libtool ? 2 : 0; // +1 for the command, +2 for libtool/mode=execute, +1 for the NULL
+ delete_argv();
+ fatal_assert(_argc == 0);
if (_use_libtool)
{
_argc+= 2; // +2 for libtool --mode=execute
}
+ _argc+= 1; // For the command
+
/*
- valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
+ valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --track-origin=yes --malloc-fill=A5 --free-fill=DE --log-file=
*/
if (_use_valgrind)
{
- _argc+= 7;
+ _argc+= 8;
+ }
+ else if (_use_ptrcheck)
+ {
+ /*
+ valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
+ */
+ _argc+= 4;
}
else if (_use_gdb) // gdb
{
}
}
- delete_argv();
+ _argc+= 1; // for the NULL
+
built_argv= new char * [_argc];
size_t x= 0;
built_argv[x++]= strdup("--leak-check=yes");
built_argv[x++]= strdup("--show-reachable=yes");
built_argv[x++]= strdup("--track-fds=yes");
+#if 0
+ built_argv[x++]= strdup("--track-origin=yes");
+#endif
built_argv[x++]= strdup("--malloc-fill=A5");
built_argv[x++]= strdup("--free-fill=DE");
+
+ std::string log_file= create_tmpfile("valgrind");
+ char buffer[1024];
+ int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
+ fatal_assert(length > 0 and length < sizeof(buffer));
+ built_argv[x++]= strdup(buffer);
+ }
+ else if (_use_ptrcheck)
+ {
+ /*
+ valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
+ */
+ built_argv[x++]= strdup("valgrind");
+ built_argv[x++]= strdup("--error-exitcode=1");
+ built_argv[x++]= strdup("--tool=exp-ptrcheck");
+ _argc+= 4;
+ std::string log_file= create_tmpfile("ptrcheck");
+ char buffer[1024];
+ int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
+ fatal_assert(length > 0 and length < sizeof(buffer));
+ built_argv[x++]= strdup(buffer);
}
else if (_use_gdb)
{
built_argv[x++]= strdup(*ptr);
}
}
- built_argv[_argc -1]= NULL;
+ built_argv[x++]= NULL;
+ fatal_assert(x == _argc);
}
std::string Application::print()
void Application::delete_argv()
{
- if (built_argv == NULL)
+ if (built_argv)
{
- return;
- }
-
- for (size_t x= 0; x < _argc; x++)
- {
- if (built_argv[x])
+ for (size_t x= 0; x < _argc; x++)
{
- ::free(built_argv[x]);
+ if (built_argv[x])
+ {
+ ::free(built_argv[x]);
+ }
}
+ delete[] built_argv;
+ built_argv= NULL;
+ _argc= 0;
}
- delete[] built_argv;
- built_argv= NULL;
- _argc= 0;
}
return int(ret);
}
- return int(app.wait());
+ return int(app.wait(false));
}
const char *gearmand_binary()
return GEARMAND_BINARY;
}
+const char *drizzled_binary()
+{
+ return DRIZZLED_BINARY;
+}
+
} // namespace exec_cmdline
projects / m6w6 / libmemcached / blobdiff