/* 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 <string>
#include <sys/stat.h>
#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+
+#ifndef __USE_GNU
+static char **environ= NULL;
+#endif
extern "C" {
static int exited_successfully(int status)
namespace {
- std::string print_argv(char * * & built_argv, const size_t& argc)
+ std::string print_argv(libtest::vchar_ptr_t& built_argv)
{
std::stringstream arg_buffer;
- for (size_t x= 0; x < argc; x++)
+ for (vchar_ptr_t::iterator iter= built_argv.begin();
+ iter == built_argv.end();
+ iter++)
{
- arg_buffer << built_argv[x] << " ";
+ arg_buffer << *iter << " ";
}
return arg_buffer.str();
}
+#if 0
std::string print_argv(char** argv)
{
std::stringstream arg_buffer;
- for (char** ptr= argv; *ptr; ptr++)
+ for (char** ptr= argv; *ptr; ++ptr)
{
arg_buffer << *ptr << " ";
}
return arg_buffer.str();
}
+#endif
static Application::error_t int_to_error_t(int arg)
{
_use_libtool(_use_libtool_arg),
_use_valgrind(false),
_use_gdb(false),
+ _use_ptrcheck(false),
+ _will_fail(false),
_argc(0),
_exectuble(arg),
- built_argv(NULL),
+ stdin_fd(STDIN_FILENO),
+ stdout_fd(STDOUT_FILENO),
+ stderr_fd(STDERR_FILENO),
_pid(-1)
{
if (_use_libtool)
{
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(file_actions);
+ stdout_fd.dup_for_spawn(file_actions);
+ stderr_fd.dup_for_spawn(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[0], 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[0], 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)
{
+ if (_will_fail == false)
+ {
+ Error << strerror(spawn_ret) << "(" << spawn_ret << ")";
+ }
+ _pid= -1;
return Application::INVALID;
}
bool Application::check() const
{
- Error << "Testing " << _exectuble;
- if (kill(_pid, 0) == 0)
+ if (_pid > 1 and kill(_pid, 0) == 0)
{
return true;
}
void Application::murder()
{
+ if (check())
+ {
+ int count= 5;
+ while ((count--) > 0 and check())
+ {
+ int kill_ret= kill(_pid, SIGTERM);
+ if (kill_ret == 0)
+ {
+ int status= 0;
+ pid_t waitpid_ret;
+ if ((waitpid_ret= waitpid(_pid, &status, WNOHANG)) == -1)
+ {
+ switch (errno)
+ {
+ case ECHILD:
+ case EINTR:
+ break;
+
+ default:
+ Error << "waitpid() failed after kill with error of " << strerror(errno);
+ break;
+ }
+ }
+
+ if (waitpid_ret == 0)
+ {
+ libtest::dream(1, 0);
+ }
+ }
+ else
+ {
+ Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno);
+ continue;
+ }
+
+ break;
+ }
+
+ // If for whatever reason it lives, kill it hard
+ if (check())
+ {
+ (void)kill(_pid, SIGKILL);
+ }
+ }
slurp();
- kill(_pid, SIGTERM);
}
// false means that no data was returned
bool Application::slurp()
{
struct pollfd fds[2];
- fds[0].fd= stdout_fd.fd()[0];
- fds[0].events= POLLIN;
+ fds[0].fd= stdout_fd.fd();
+ fds[0].events= POLLRDNORM;
fds[0].revents= 0;
- fds[1].fd= stderr_fd.fd()[0];
- fds[1].events= POLLIN;
+ fds[1].fd= stderr_fd.fd();
+ fds[1].events= POLLRDNORM;
fds[1].revents= 0;
int active_fd;
- if ((active_fd= poll(fds, 2, 400)) == -1)
+ if ((active_fd= poll(fds, 2, 0)) == -1)
{
int error;
switch ((error= errno))
fatal_message(strerror(error));
break;
}
+
+ return false;
}
if (active_fd == 0)
return false;
}
- if (fds[0].revents & POLLIN)
+ bool data_was_read= false;
+ if (fds[0].revents & POLLRDNORM)
{
- ssize_t read_length;
- char buffer[1024]= { 0 };
- while ((read_length= ::read(stdout_fd.fd()[0], buffer, sizeof(buffer))))
+ if (stdout_fd.read(_stdout_buffer) == true)
{
- if (read_length == -1)
- {
- switch(errno)
- {
- case EAGAIN:
- continue;
-
- default:
- Error << strerror(errno);
- break;
- }
+ data_was_read= true;
+ }
+ }
- break;
- }
- _stdout_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
- {
- _stdout_buffer.push_back(buffer[x]);
- }
- // @todo Suck up all output code here
+ if (fds[1].revents & POLLRDNORM)
+ {
+ if (stderr_fd.read(_stderr_buffer) == true)
+ {
+ data_was_read= true;
}
}
- if (fds[1].revents & POLLIN)
+ return data_was_read;
+}
+
+Application::error_t Application::wait(bool nohang)
+{
+ if (_pid == -1)
{
- stderr_fd.nonblock();
+ return Application::INVALID;
+ }
+
+ slurp();
- ssize_t read_length;
- char buffer[1024]= { 0 };
- while ((read_length= ::read(stderr_fd.fd()[0], buffer, sizeof(buffer))))
+ error_t exit_code= FAILURE;
+ {
+ int status= 0;
+ pid_t waited_pid;
+ if ((waited_pid= waitpid(_pid, &status, nohang ? WNOHANG : 0)) == -1)
{
- if (read_length == -1)
+ switch (errno)
{
- switch(errno)
- {
- case EAGAIN:
- continue;
+ case ECHILD:
+ exit_code= Application::SUCCESS;
+ break;
- default:
- Error << strerror(errno);
- break;
- }
+ case EINTR:
+ break;
+ default:
+ Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
break;
}
- _stderr_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
+ }
+ else if (waited_pid == 0)
+ {
+ exit_code= Application::SUCCESS;
+ }
+ else
+ {
+ if (waited_pid != _pid)
{
- _stderr_buffer.push_back(buffer[x]);
+ throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid));
}
- // @todo Suck up all errput code here
+ exit_code= int_to_error_t(exited_successfully(status));
}
}
- return true;
+ slurp();
+
+#if 0
+ if (exit_code == Application::INVALID)
+ {
+ Error << print_argv(built_argv, _argc);
+ }
+#endif
+
+ return exit_code;
}
-Application::error_t Application::wait()
+Application::error_t Application::join()
{
- fatal_assert(_pid != -1);
+ if (_pid == -1)
+ {
+ return Application::INVALID;
+ }
slurp();
{
int status= 0;
pid_t waited_pid;
- if ((waited_pid= waitpid(_pid, &status, 0)) == -1)
+ do {
+ waited_pid= waitpid(_pid, &status, 0);
+ } while (waited_pid == -1 and (errno == EINTR or errno == EAGAIN));
+
+ if (waited_pid == -1)
{
switch (errno)
{
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)
+ {
+ exit_code= Application::SUCCESS;
+ }
else
{
if (waited_pid != _pid)
{
throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid));
}
+
exit_code= int_to_error_t(exited_successfully(status));
}
}
+ slurp();
+
#if 0
if (exit_code == Application::INVALID)
{
_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()
+{
+ 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)
{
- _fd[0]= -1;
- _fd[1]= -1;
- _open[0]= false;
- _open[1]= false;
+ 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 < size_t(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(_fd[0], F_GETFL, 0)) == -1)
+ if ((ret= fcntl(_pipe_fd[READ], F_GETFL, 0)) == -1)
{
Error << "fcntl(F_GETFL) " << strerror(errno);
throw strerror(errno);
}
- if ((ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK)) == -1)
+ if ((ret= fcntl(_pipe_fd[READ], F_SETFL, ret | O_NONBLOCK)) == -1)
{
Error << "fcntl(F_SETFL) " << strerror(errno);
throw strerror(errno);
close(READ);
close(WRITE);
- if (pipe(_fd) == -1)
+#if HAVE_PIPE2
+ if (pipe2(_pipe_fd, O_NONBLOCK) == -1)
+#else
+ if (pipe(_pipe_fd) == -1)
+#endif
{
- throw strerror(errno);
+ fatal_message(strerror(errno));
}
_open[0]= true;
_open[1]= true;
- if (0)
+ if (true)
{
nonblock();
+ cloexec();
+ }
+}
+
+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);
}
}
Application::Pipe::~Pipe()
{
- close(READ);
- close(WRITE);
+ if (_pipe_fd[0] != -1)
+ {
+ ::close(_pipe_fd[0]);
+ }
+
+ if (_pipe_fd[1] != -1)
+ {
+ ::close(_pipe_fd[1]);
+ }
}
-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(posix_spawn_file_actions_t& file_actions)
{
- int type= int(arg);
+ int type= STDIN_FILENO == _std_fd ? 0 : 1;
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 (::close(_fd[type]) == -1)
+ if (::close(_pipe_fd[type]) == -1)
{
Error << "close(" << strerror(errno) << ")";
}
_open[type]= false;
- _fd[type]= -1;
+ _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
-
- if (_use_libtool)
- {
- _argc+= 2; // +2 for libtool --mode=execute
- }
-
- /*
- valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
- */
- if (_use_valgrind)
- {
- _argc+= 7;
- }
- else if (_use_gdb) // gdb
- {
- _argc+= 1;
- }
-
- for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++)
- {
- _argc++;
- if ((*iter).second.empty() == false)
- {
- _argc++;
- }
- }
-
- if (args)
- {
- for (const char **ptr= args; *ptr; ++ptr)
- {
- _argc++;
- }
- }
-
delete_argv();
- built_argv= new char * [_argc];
-
- size_t x= 0;
if (_use_libtool)
{
assert(libtool());
- built_argv[x++]= strdup(libtool());
- built_argv[x++]= strdup("--mode=execute");
+ built_argv.push_back(strdup(libtool()));
+ built_argv.push_back(strdup("--mode=execute"));
}
if (_use_valgrind)
/*
valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
*/
- built_argv[x++]= strdup("valgrind");
- built_argv[x++]= strdup("--error-exitcode=1");
- built_argv[x++]= strdup("--leak-check=yes");
- built_argv[x++]= strdup("--show-reachable=yes");
- built_argv[x++]= strdup("--track-fds=yes");
- built_argv[x++]= strdup("--malloc-fill=A5");
- built_argv[x++]= strdup("--free-fill=DE");
+ built_argv.push_back(strdup("valgrind"));
+ built_argv.push_back(strdup("--error-exitcode=1"));
+ built_argv.push_back(strdup("--leak-check=yes"));
+ built_argv.push_back(strdup("--show-reachable=yes"));
+ built_argv.push_back(strdup("--track-fds=yes"));
+#if 0
+ built_argv[x++]= strdup("--track-origin=yes");
+#endif
+ built_argv.push_back(strdup("--malloc-fill=A5"));
+ built_argv.push_back(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 size_t(length) < sizeof(buffer));
+ built_argv.push_back(strdup(buffer));
+ }
+ else if (_use_ptrcheck)
+ {
+ /*
+ valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
+ */
+ built_argv.push_back(strdup("valgrind"));
+ built_argv.push_back(strdup("--error-exitcode=1"));
+ built_argv.push_back(strdup("--tool=exp-ptrcheck"));
+ 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 size_t(length) < sizeof(buffer));
+ built_argv.push_back(strdup(buffer));
}
else if (_use_gdb)
{
- built_argv[x++]= strdup("gdb");
+ built_argv.push_back(strdup("gdb"));
}
- built_argv[x++]= strdup(_exectuble_with_path.c_str());
+ built_argv.push_back(strdup(_exectuble_with_path.c_str()));
- for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++)
+ for (Options::const_iterator iter= _options.begin(); iter != _options.end(); ++iter)
{
- built_argv[x++]= strdup((*iter).first.c_str());
+ built_argv.push_back(strdup((*iter).first.c_str()));
if ((*iter).second.empty() == false)
{
- built_argv[x++]= strdup((*iter).second.c_str());
+ built_argv.push_back(strdup((*iter).second.c_str()));
}
}
{
for (const char **ptr= args; *ptr; ++ptr)
{
- built_argv[x++]= strdup(*ptr);
+ built_argv.push_back(strdup(*ptr));
}
}
- built_argv[_argc -1]= NULL;
+ built_argv.push_back(NULL);
}
std::string Application::print()
{
- return print_argv(built_argv, _argc);
+ return print_argv(built_argv);
}
std::string Application::arguments()
{
std::stringstream arg_buffer;
- for (size_t x= 1 + _use_libtool ? 2 : 0;
+ for (size_t x= (1 +_use_libtool) ? 2 : 0;
x < _argc and built_argv[x];
- x++)
+ ++x)
{
arg_buffer << built_argv[x] << " ";
}
return arg_buffer.str();
}
-void Application::delete_argv()
+struct DeleteFromVector
{
- if (built_argv)
- {
- for (size_t x= 0; x < _argc; x++)
+ template <class T>
+ void operator() ( T* ptr) const
{
- if (built_argv[x])
- {
- ::free(built_argv[x]);
- }
+ free(ptr);
}
- delete[] built_argv;
- built_argv= NULL;
- _argc= 0;
- }
+};
+
+void Application::delete_argv()
+{
+ std::for_each(built_argv.begin(), built_argv.end(), DeleteFromVector());
+
+ built_argv.clear();
+ _argc= 0;
}
return int(ret);
}
- return int(app.wait());
+ return int(app.join());
}
const char *gearmand_binary()
return GEARMAND_BINARY;
}
+const char *drizzled_binary()
+{
+ return DRIZZLED_BINARY;
+}
+
} // namespace exec_cmdline