-rw-r--r-- | src/configuration.cc | 5 | ||||
-rw-r--r-- | src/dudki.cc | 5 | ||||
-rw-r--r-- | src/process.cc | 98 | ||||
-rw-r--r-- | src/process.h | 6 |
4 files changed, 113 insertions, 1 deletions
diff --git a/src/configuration.cc b/src/configuration.cc index eb010c1..edc8c04 100644 --- a/src/configuration.cc +++ b/src/configuration.cc @@ -79,56 +79,61 @@ static DOTCONF_CB(dco_notify) { dc_context *dcc = (dc_context*)ctx; } static DOTCONF_CB(dco_process) { dc_context *dcc = (dc_context*)ctx; string id = cmd->data.str; if(id[id.length()-1]=='>') id.erase(id.length()-1); dcc->ps = &(dcc->cf->processes[id]); dcc->ctx = DCC_PROCESS; return NULL; } static DOTCONF_CB(dco__process) { dc_context *dcc = (dc_context*)ctx; dcc->ps = NULL; dcc->ctx = DCC_ROOT; return NULL; } +static DOTCONF_CB(dco_process_name) { dc_context *dcc = (dc_context*)ctx; + dcc->ps->process_name = cmd->data.str; + return NULL; +} static DOTCONF_CB(dco_restart_command) { dc_context *dcc = (dc_context*)ctx; dcc->ps->restart_cmd = cmd->data.str; return NULL; } static DOTCONF_CB(dco_user) { dc_context *dcc = (dc_context*)ctx; dcc->ps->user = cmd->data.str; return NULL; } static DOTCONF_CB(dco_group) { dc_context *dcc = (dc_context*)ctx; dcc->ps->group = cmd->data.str; return NULL; } static DOTCONF_CB(dco_chroot) { dc_context *dcc = (dc_context*)ctx; dcc->ps->chroot = cmd->data.str; return NULL; } static const configoption_t dc_options[] = { { "CheckInterval", ARG_INT, dco_check_interval, NULL, DCC_ROOT }, { "Daemonize", ARG_TOGGLE, dco_daemonize, NULL, DCC_ROOT }, { "PidFile", ARG_STR, dco_pid_file, NULL, DCC_ROOT|DCC_PROCESS }, { "MailtoHeader", ARG_STR, dco_mailto_header, NULL, DCC_ROOT|DCC_PROCESS }, { "Notify", ARG_STR, dco_notify, NULL, DCC_ROOT|DCC_PROCESS }, { "<Process", ARG_STR, dco_process, NULL, DCC_ROOT }, + { "ProcessName", ARG_STR, dco_process_name, NULL, DCC_PROCESS }, { "RestartCommand", ARG_STR, dco_restart_command, NULL, DCC_PROCESS }, { "User", ARG_STR, dco_user, NULL, DCC_PROCESS }, { "Group", ARG_STR, dco_group, NULL, DCC_PROCESS }, { "Chroot", ARG_STR, dco_chroot, NULL, DCC_PROCESS }, { "</Process>", ARG_NONE, dco__process, NULL, DCC_PROCESS }, LAST_OPTION }; static const char *dc_context_checker(command_t *cmd,unsigned long mask) { dc_context *dcc = (dc_context*)cmd->context; if( (mask==CTX_ALL) || ((mask&dcc->ctx)==dcc->ctx) ) return NULL; return "misplaced option"; } static FUNC_ERRORHANDLER(dc_error_handler) { throw runtime_error(string("error parsing config file: ")+msg); diff --git a/src/dudki.cc b/src/dudki.cc index 9562079..c966695 100644 --- a/src/dudki.cc +++ b/src/dudki.cc @@ -22,34 +22,36 @@ using namespace std; #define PCOPY "Copyright (c) 2004 Klever Group" bool finishing = false; bool restarting = false; static char **_argv = NULL; static void lethal_signal_handler(int signum) { syslog(LOG_NOTICE,"Lethal signal received. Terminating."); finishing = true; } static void sighup_handler(int signum) { syslog(LOG_NOTICE,"SUGHUP received, reloading."); restarting = finishing = true; } void check_herd(configuration& config) { + process::prepare_herd(); for(processes_t::iterator i=config.processes.begin();i!=config.processes.end();++i) i->second.check(i->first,config); + process::unprepare_herd(); } void signal_self(const configuration& config,int signum) { ifstream pids(config.pidfile.c_str(),ios::in); if(!pids) throw runtime_error("Can't detect running instance"); pid_t pid = 0; pids >> pid; if(!pid) throw runtime_error("Can't detect running instance"); if(pid==getpid()) throw 0; if(kill(pid,signum)) throw runtime_error("Failed to signal running instance"); } @@ -207,33 +209,36 @@ int main(int argc,char **argv) { config.parse(config_file); switch(op) { case op_test: cerr << "Configuration OK" << endl; break; case op_signal: try { if(optind>=argc) { signal_self(config,op_signum); }else{ int failures = 0; for(int narg=optind;narg<argc;narg++) { try { processes_t::const_iterator i = config.processes.find(argv[narg]); if(i==config.processes.end()) throw runtime_error("no such process configured"); + if(op_signum) i->second.signal(op_signum); + else + i->second.check(); }catch(exception& e) { cerr << "dudki(" << argv[narg] << "): " << e.what() << endl; failures++; } } if(failures) throw runtime_error("not all processes have been successfully signaled"); } if(!op_signum) exit(0); }catch(exception& e) { if(!op_signum) exit(1); } case op_ensure: try { diff --git a/src/process.cc b/src/process.cc index 1ffac9f..8a5b5d2 100644 --- a/src/process.cc +++ b/src/process.cc @@ -1,35 +1,51 @@ #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <signal.h> #include <pwd.h> #include <grp.h> +#include <dirent.h> #include <sys/wait.h> #include <syslog.h> #include <errno.h> #include <iostream> #include <fstream> +#include <sstream> #include <stdexcept> +#include <string> +#include <vector> using namespace std; #include "process.h" #include "configuration.h" +static multimap<string,pid_t> procpids; + +void process::check() const { + if(!pidfile.empty()) { + signal(0); + }else if(!process_name.empty()) { + if(procpids.empty()) + gather_proc_info(); + if(procpids.find(process_name)==procpids.end()) + throw runtime_error("no such process"); + } // XXX: or else? +} void process::check(const string& id,configuration& config) { try { - signal(0); + check(); patience = 0; }catch(exception& e) { if(patience>60) { // TODO: configurable patience = 0; }else{ if(patience<10) { // TODO: configurable syslog(LOG_NOTICE,"The process '%s' is down, trying to launch.",id.c_str()); do_notify(id,"Starting up", "The named process seems to be down. Dudki will try\n" "to revive it by running the specified command.\n", config); try { launch(id,config); }catch(exception& e) { syslog(LOG_ERR,"Error trying to launch process '%s': %s",id.c_str(),e.what()); } @@ -163,27 +179,107 @@ void process::notify_mailto(const string& email,const string& id,const string& e fprintf(mta,"%s: %s\n",i->first.c_str(),i->second.c_str()); } fprintf(mta, "Subject: [%s] %s\n\n" "%s\n" "---\n" "This message was sent automatically by the 'dudki' daemon\n", id.c_str(), event.c_str(), description.c_str() ); fclose(mta); int status; waitpid(pid,&status,0); // TODO: check the return code } void process::signal(int signum) const { + if(!pidfile.empty()) { ifstream pids(pidfile.c_str(),ios::in); if(!pids) throw runtime_error("no pidfile found"); pid_t pid = 0; pids >> pid; pids.close(); if(!pid) throw runtime_error("no pid in pidfile"); if(kill(pid,signum)) throw runtime_error("failed to signal process"); + }else if(!process_name.empty()) { + if(procpids.empty()) + gather_proc_info(); + pair<multimap<string,pid_t>::const_iterator,multimap<string,pid_t>::const_iterator> range = procpids.equal_range(process_name); + int count = 0; + for(multimap<string,pid_t>::const_iterator i=range.first;i!=range.second;++i) { + pid_t pid = i->second; + if(kill(i->second,signum)) + throw runtime_error("failed to signal process"); + count++; + } + if(!count) + throw runtime_error("no running instance detected"); + }else + throw runtime_error("nothing is known about the process"); +} + +void process::prepare_herd() { + procpids.clear(); +} +void process::unprepare_herd() { + procpids.clear(); +} +void process::gather_proc_info() { + vector<pid_t> allpids; + DIR *pd = opendir("/proc"); + if(!pd) + throw runtime_error("failed to open /proc"); + struct dirent *pde; + pid_t selfpid = getpid(); + while(pde=readdir(pd)) { + errno=0; + pid_t pid = atoi(pde->d_name); + if((!pid) || pid==selfpid) + continue; + allpids.push_back(pid); + } + closedir(pd); + char s[256]; + procpids.clear(); + for(vector<pid_t>::const_iterator i=allpids.begin();i!=allpids.end();++i) { + int r = snprintf(s,sizeof(s),"/proc/%d/stat",*i); + if(r>=sizeof(s) || r<1) + continue; + string cmd; + ifstream ss(s,ios::in); + if(!ss) + continue; + getline(ss,cmd); + string::size_type op = cmd.find('('); + if(op==string::npos) + continue; + cmd.erase(0,op+1); + string::size_type cp = cmd.find(')'); + if(cp==string::npos) + continue; + cmd.erase(cp); + r = snprintf(s,sizeof(s),"/proc/%d/cmdline",*i); + if(r>=sizeof(s) || r<1) + continue; + ifstream cs(s,ios::binary); + if(!cs) + continue; + string command; + while(cs) { + string cl; + getline(cs,cl,(char)0); + string::size_type lsl = cl.rfind('/'); + if(lsl!=string::npos) + cl.erase(0,lsl+1); + if(cl.substr(0,cmd.length())==cmd) { + command = cl; + break; + } + } + procpids.insert(pair<string,pid_t>(cmd,*i)); + if((!command.empty()) && cmd!=command) + procpids.insert(pair<string,pid_t>(command,*i)); + } } diff --git a/src/process.h b/src/process.h index 27ee049..90b12d9 100644 --- a/src/process.h +++ b/src/process.h @@ -1,38 +1,44 @@ #ifndef __PROCESS_H #define __PROCESS_H #include <string> #include <map> using namespace std; class configuration; typedef map<string,string> headers_t; class process { public: string pidfile; + string process_name; string restart_cmd; string notify; string user; string group; string chroot; headers_t mailto_headers; int patience; process() : patience(0) { } void check(const string& id,configuration& config); void launch(const string& id,configuration& config); void do_notify(const string& id,const string& event,const string& description,configuration& config); void notify_mailto(const string& email,const string& id,const string& event, const string& description,configuration& config); void signal(int signum) const; + void check() const; + + static void prepare_herd(); + static void gather_proc_info(); + static void unprepare_herd(); }; typedef map<string,process> processes_t; #endif /* __PROCESS_H */ |