Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/Rest/AnyServer.cpp

556 lines
15 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
////////////////////////////////////////////////////////////////////////////////
#include "AnyServer.h"
#ifdef TRI_HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef TRI_HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
#include "ApplicationServer/ApplicationServer.h"
#include "Basics/FileUtils.h"
#include "Basics/logging.h"
#include "Basics/process-utils.h"
#include <fstream>
using namespace std;
using namespace triagens;
using namespace triagens::basics;
using namespace triagens::rest;
////////////////////////////////////////////////////////////////////////////////
/// @brief writes a pid file
////////////////////////////////////////////////////////////////////////////////
static void WritePidFile(std::string const& pidFile, int pid) {
ofstream out(pidFile.c_str(), ios::trunc);
if (!out) {
LOG_FATAL_AND_EXIT("cannot write pid-file '%s'", pidFile.c_str());
}
out << pid;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief checks a pid file
////////////////////////////////////////////////////////////////////////////////
static void CheckPidFile(std::string const& pidFile) {
// check if the pid-file exists
if (!pidFile.empty()) {
if (FileUtils::isDirectory(pidFile)) {
LOG_FATAL_AND_EXIT("pid-file '%s' is a directory", pidFile.c_str());
} else if (FileUtils::exists(pidFile) && FileUtils::size(pidFile) > 0) {
LOG_INFO("pid-file '%s' already exists, verifying pid", pidFile.c_str());
ifstream f(pidFile.c_str());
// file can be opened
if (f) {
TRI_pid_t oldPid;
f >> oldPid;
if (oldPid == 0) {
LOG_FATAL_AND_EXIT("pid-file '%s' is unreadable", pidFile.c_str());
}
LOG_DEBUG("found old pid: %d", (int)oldPid);
#ifdef TRI_HAVE_FORK
int r = kill(oldPid, 0);
#else
int r = 0; // TODO for windows use TerminateProcess
#endif
if (r == 0) {
LOG_FATAL_AND_EXIT(
"pid-file '%s' exists and process with pid %d is still running",
pidFile.c_str(), (int)oldPid);
} else if (errno == EPERM) {
LOG_FATAL_AND_EXIT(
"pid-file '%s' exists and process with pid %d is still running",
pidFile.c_str(), (int)oldPid);
} else if (errno == ESRCH) {
LOG_ERROR("pid-file '%s exists, but no process with pid %d exists",
pidFile.c_str(), (int)oldPid);
if (!FileUtils::remove(pidFile)) {
LOG_FATAL_AND_EXIT(
"pid-file '%s' exists, no process with pid %d exists, but "
"pid-file cannot be removed",
pidFile.c_str(), (int)oldPid);
}
LOG_INFO("removed stale pid-file '%s'", pidFile.c_str());
} else {
LOG_FATAL_AND_EXIT("pid-file '%s' exists and kill %d failed",
pidFile.c_str(), (int)oldPid);
}
}
// failed to open file
else {
LOG_FATAL_AND_EXIT("pid-file '%s' exists, but cannot be opened",
pidFile.c_str());
}
}
LOG_DEBUG("using pid-file '%s'", pidFile.c_str());
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief forks a new process
////////////////////////////////////////////////////////////////////////////////
#ifdef TRI_HAVE_FORK
static int ForkProcess(std::string const& workingDirectory, std::string& current) {
// fork off the parent process
TRI_pid_t pid = fork();
if (pid < 0) {
LOG_FATAL_AND_EXIT("cannot fork");
}
// Upon successful completion, fork() shall return 0 to the child process and
// shall return the process ID of the child process to the parent process.
// if we got a good PID, then we can exit the parent process
if (pid > 0) {
LOG_DEBUG("started child process with pid %d", (int)pid);
return pid;
}
// change the file mode mask
umask(0);
// create a new SID for the child process
TRI_pid_t sid = setsid();
if (sid < 0) {
LOG_FATAL_AND_EXIT("cannot create sid");
}
// store current working directory
int err = 0;
current = FileUtils::currentDirectory(&err);
if (err != 0) {
LOG_FATAL_AND_EXIT("cannot get current directory");
}
// change the current working directory
if (!workingDirectory.empty()) {
if (!FileUtils::changeDirectory(workingDirectory)) {
LOG_FATAL_AND_EXIT("cannot change into working directory '%s'",
workingDirectory.c_str());
} else {
LOG_INFO("changed working directory for child process to '%s'",
workingDirectory.c_str());
}
}
// we're a daemon so there won't be a terminal attached
// close the standard file descriptors and re-open them mapped to /dev/null
int fd = open("/dev/null", O_RDWR | O_CREAT, 0644);
if (fd < 0) {
LOG_FATAL_AND_EXIT("cannot open /dev/null");
}
if (dup2(fd, STDIN_FILENO) < 0) {
LOG_FATAL_AND_EXIT("cannot re-map stdin to /dev/null");
}
if (dup2(fd, STDOUT_FILENO) < 0) {
LOG_FATAL_AND_EXIT("cannot re-map stdout to /dev/null");
}
if (dup2(fd, STDERR_FILENO) < 0) {
LOG_FATAL_AND_EXIT("cannot re-map stderr to /dev/null");
}
close(fd);
return 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief waits for the supervisor process with pid to return its exit status
/// waits for at most 10 seconds. if the supervisor has not returned until then,
/// we assume a successful start
////////////////////////////////////////////////////////////////////////////////
int WaitForSupervisor(int pid) {
if (!isatty(STDIN_FILENO)) {
// during system boot, we don't have a tty, and we don't want to delay
// the boot process
return EXIT_SUCCESS;
}
// in case a tty is present, this is probably a manual invocation of the start
// procedure
double const end = TRI_microtime() + 10.0;
while (TRI_microtime() < end) {
int status;
int res = waitpid(pid, &status, WNOHANG);
if (res == -1) {
// error in waitpid. don't know what to do
break;
}
if (res != 0 && WIFEXITED(status)) {
// give information about supervisor exit code
if (WEXITSTATUS(status) == 0) {
// exit code 0
return EXIT_SUCCESS;
} else if (WIFSIGNALED(status)) {
switch (WTERMSIG(status)) {
case 2:
case 9:
case 15:
// terminated normally
return EXIT_SUCCESS;
default:
break;
}
}
// failure!
LOG_ERROR(
"unable to start arangod. please check the logfiles for errors");
return EXIT_FAILURE;
}
// sleep a while and retry
usleep(500 * 1000);
}
// enough time has elapsed... we now abort our loop
return EXIT_SUCCESS;
}
#else
// .............................................................................
// TODO: use windows API CreateProcess & CreateThread to minic fork()
// .............................................................................
static int ForkProcess(std::string const& workingDirectory, std::string& current) {
// fork off the parent process
TRI_pid_t pid = -1; // fork();
if (pid < 0) {
LOG_FATAL_AND_EXIT("cannot fork");
}
return 0;
}
#endif
AnyServer::AnyServer()
: _mode(ServerMode::MODE_STANDALONE),
_daemonMode(false),
_supervisorMode(false),
_pidFile(""),
_workingDirectory(""),
_applicationServer(nullptr) {}
AnyServer::~AnyServer() { delete _applicationServer; }
////////////////////////////////////////////////////////////////////////////////
/// @brief starts the server
////////////////////////////////////////////////////////////////////////////////
int AnyServer::start() {
startupProgress();
if (_applicationServer == nullptr) {
buildApplicationServer();
}
startupProgress();
if (_supervisorMode) {
return startupSupervisor();
} else if (_daemonMode) {
return startupDaemon();
} else {
_applicationServer->setupLogging(true, false, false);
startupProgress();
if (!_pidFile.empty()) {
CheckPidFile(_pidFile);
WritePidFile(_pidFile, TRI_CurrentProcessId());
}
startupProgress();
int res = startupServer();
if (!_pidFile.empty()) {
if (!FileUtils::remove(_pidFile)) {
LOG_DEBUG("cannot remove pid file '%s'", _pidFile.c_str());
}
}
startupProgress();
return res;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief begins shutdown sequence
////////////////////////////////////////////////////////////////////////////////
void AnyServer::beginShutdown() {
if (_applicationServer != nullptr) {
_applicationServer->beginShutdown();
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief starts a supervisor
////////////////////////////////////////////////////////////////////////////////
#ifdef TRI_HAVE_FORK
int AnyServer::startupSupervisor() {
static time_t const MIN_TIME_ALIVE_IN_SEC = 30;
LOG_INFO("starting up in supervisor mode");
CheckPidFile(_pidFile);
_applicationServer->setupLogging(false, true, false);
std::string current;
int result = ForkProcess(_workingDirectory, current);
// main process
if (result != 0) {
// wait for a few seconds for the supervisor to return
// if it returns within a reasonable time, we can fetch its exit code
// and report it
return WaitForSupervisor(result);
}
// child process
else {
setMode(ServerMode::MODE_SERVICE);
time_t startTime = time(0);
time_t t;
bool done = false;
result = 0;
while (!done) {
// fork of the server
TRI_pid_t pid = fork();
if (pid < 0) {
TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL);
}
// parent
if (0 < pid) {
_applicationServer->setupLogging(false, true, true);
TRI_SetProcessTitle("arangodb [supervisor]");
LOG_DEBUG("supervisor mode: within parent");
int status;
waitpid(pid, &status, 0);
bool horrible = true;
if (WIFEXITED(status)) {
// give information about cause of death
if (WEXITSTATUS(status) == 0) {
LOG_INFO("child %d died of natural causes", (int)pid);
done = true;
horrible = false;
} else {
t = time(0) - startTime;
LOG_ERROR("child %d died a horrible death, exit status %d",
(int)pid, (int)WEXITSTATUS(status));
if (t < MIN_TIME_ALIVE_IN_SEC) {
LOG_ERROR(
"child only survived for %d seconds, this will not work - "
"please fix the error first",
(int)t);
done = true;
} else {
done = false;
}
}
} else if (WIFSIGNALED(status)) {
switch (WTERMSIG(status)) {
case 2:
case 9:
case 15:
LOG_INFO("child %d died of natural causes, exit status %d",
(int)pid, (int)WTERMSIG(status));
done = true;
horrible = false;
break;
default:
t = time(0) - startTime;
LOG_ERROR("child %d died a horrible death, signal %d", (int)pid,
(int)WTERMSIG(status));
if (t < MIN_TIME_ALIVE_IN_SEC) {
LOG_ERROR(
"child only survived for %d seconds, this will not work - "
"please fix the error first",
(int)t);
done = true;
#ifdef WCOREDUMP
if (WCOREDUMP(status)) {
LOG_WARNING("child process %d produced a core dump",
(int)pid);
}
#endif
} else {
done = false;
}
break;
}
} else {
LOG_ERROR("child %d died a horrible death, unknown cause", (int)pid);
done = false;
}
// remove pid file
if (horrible) {
if (!FileUtils::remove(_pidFile)) {
LOG_DEBUG("cannot remove pid file '%s'", _pidFile.c_str());
}
result = EXIT_FAILURE;
}
}
// child
else {
_applicationServer->setupLogging(true, false, true);
LOG_DEBUG("supervisor mode: within child");
// write the pid file
WritePidFile(_pidFile, TRI_CurrentProcessId());
// force child to stop if supervisor dies
#ifdef TRI_HAVE_PRCTL
prctl(PR_SET_PDEATHSIG, SIGTERM, 0, 0, 0);
#endif
// startup server
result = startupServer();
// remove pid file
if (!FileUtils::remove(_pidFile)) {
LOG_DEBUG("cannot remove pid file '%s'", _pidFile.c_str());
}
// and stop
TRI_EXIT_FUNCTION(result, NULL);
}
}
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief starts a daemon
////////////////////////////////////////////////////////////////////////////////
int AnyServer::startupDaemon() {
LOG_INFO("starting up in daemon mode");
CheckPidFile(_pidFile);
_applicationServer->setupLogging(false, true, false);
std::string current;
int result = ForkProcess(_workingDirectory, current);
// main process
if (result != 0) {
TRI_SetProcessTitle("arangodb [daemon]");
WritePidFile(_pidFile, result);
// issue #549: this is used as the exit code
result = 0;
}
// child process
else {
setMode(ServerMode::MODE_SERVICE);
_applicationServer->setupLogging(true, false, true);
LOG_DEBUG("daemon mode: within child");
// and startup server
result = startupServer();
// remove pid file
if (!FileUtils::remove(_pidFile)) {
LOG_DEBUG("cannot remove pid file '%s'", _pidFile.c_str());
}
}
return result;
}
#else
int AnyServer::startupSupervisor() { return 0; }
int AnyServer::startupDaemon() { return 0; }
#endif
Reference in New Issue View Git Blame Copy Permalink