Fix another minor leak.

[cubemap] / main.cpp

diff --git a/main.cpp b/main.cpp
index 4a5904b0715f1905817210138e3c9b7091329fae..55548bae91e832c02450a2196bf9778cea39453f 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <getopt.h>
+#include <limits.h>
 #include <signal.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -15,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "accesslog.h"
 #include "acceptor.h"
 #include "config.h"
 #include "input.h"
@@ -28,12 +30,18 @@
 
 using namespace std;
 
+AccessLogThread *access_log = NULL;
 ServerPool *servers = NULL;
+vector<MarkPool *> mark_pools;
 volatile bool hupped = false;
+volatile bool stopped = false;
 
-void hup(int ignored)
+void hup(int signum)
 {
        hupped = true;
+       if (signum == SIGINT) {
+               stopped = true;
+       }
 }
 
 CubemapStateProto collect_state(const timeval &serialize_start,
@@ -135,7 +143,6 @@ void create_streams(const Config &config,
                     const set<string> &deserialized_stream_ids,
                    map<string, Input *> *deserialized_inputs)
 {
-       vector<MarkPool *> mark_pools;  // FIXME: leak
        for (unsigned i = 0; i < config.mark_pools.size(); ++i) {
                const MarkPoolConfig &mp_config = config.mark_pools[i];
                mark_pools.push_back(new MarkPool(mp_config.from, mp_config.to));
@@ -231,6 +238,7 @@ bool dry_run_config(const std::string &argv0, const std::string &config_filename
 int main(int argc, char **argv)
 {
        signal(SIGHUP, hup);
+       signal(SIGINT, hup);
        signal(SIGPIPE, SIG_IGN);
        
        // Parse options.
@@ -264,19 +272,51 @@ int main(int argc, char **argv)
                config_filename = argv[optind++];
        }
 
+       // Canonicalize argv[0] and config_filename.
+       char argv0_canon[PATH_MAX];
+       char config_filename_canon[PATH_MAX];
+
+       if (realpath(argv[0], argv0_canon) == NULL) {
+               log_perror(argv[0]);
+               exit(1);
+       }
+       if (realpath(config_filename.c_str(), config_filename_canon) == NULL) {
+               log_perror(config_filename.c_str());
+               exit(1);
+       }
+
+       // Now parse the configuration file.
        Config config;
-       if (!parse_config(config_filename, &config)) {
+       if (!parse_config(config_filename_canon, &config)) {
                exit(1);
        }
        if (test_config) {
                exit(0);
        }
+       
+       // Ideally we'd like to daemonize only when we've started up all threads etc.,
+       // but daemon() forks, which is not good in multithreaded software, so we'll
+       // have to do it here.
+       if (config.daemonize) {
+               if (daemon(0, 0) == -1) {
+                       log_perror("daemon");
+                       exit(1);
+               }
+       }
 
 start:
        // Open logs as soon as possible.
        open_logs(config.log_destinations);
 
-       log(NO_LEVEL, "Cubemap " SERVER_VERSION " starting.");
+       log(INFO, "Cubemap " SERVER_VERSION " starting.");
+       if (config.access_log_file.empty()) {
+               // Create a dummy logger.
+               access_log = new AccessLogThread();
+       } else {
+               access_log = new AccessLogThread(config.access_log_file);
+       }
+       access_log->run();
+
        servers = new ServerPool(config.num_servers);
 
        CubemapStateProto loaded_state;
@@ -366,6 +406,7 @@ start:
 
        if (stats_thread != NULL) {
                stats_thread->stop();
+               delete stats_thread;
        }
        for (size_t i = 0; i < acceptors.size(); ++i) {
                acceptors[i]->stop();
@@ -375,35 +416,52 @@ start:
        }
        servers->stop();
 
-       log(INFO, "Serializing state and re-execing...");
-       CubemapStateProto state = collect_state(
-                serialize_start, acceptors, inputs, servers);
-       string serialized;
-       state.SerializeToString(&serialized);
-       state_fd = make_tempfile(serialized);
-       if (state_fd == -1) {
-               exit(1);
+       CubemapStateProto state;
+       if (stopped) {
+               log(INFO, "Shutting down.");
+       } else {
+               log(INFO, "Serializing state and re-execing...");
+               state = collect_state(
+                       serialize_start, acceptors, inputs, servers);
+               string serialized;
+               state.SerializeToString(&serialized);
+               state_fd = make_tempfile(serialized);
+               if (state_fd == -1) {
+                       exit(1);
+               }
        }
        delete servers;
+
+       for (unsigned i = 0; i < mark_pools.size(); ++i) {
+               delete mark_pools[i];
+       }
+       mark_pools.clear();
+
+       access_log->stop();
+       delete access_log;
        shut_down_logging();
 
-       if (!dry_run_config(argv[0], config_filename)) {
+       if (stopped) {
+               exit(0);
+       }
+
+       // OK, so the signal was SIGHUP. Check that the new config is okay, then exec the new binary.
+       if (!dry_run_config(argv0_canon, config_filename_canon)) {
                open_logs(config.log_destinations);
                log(ERROR, "%s --test-config failed. Restarting old version instead of new.", argv[0]);
                hupped = false;
                shut_down_logging();
                goto start;
        }
-
         
        char buf[16];
        sprintf(buf, "%d", state_fd);
 
        for ( ;; ) {
-               execlp(argv[0], argv[0], config_filename.c_str(), "--state", buf, NULL);
+               execlp(argv0_canon, argv0_canon, config_filename_canon, "--state", buf, NULL);
                open_logs(config.log_destinations);
                log_perror("execlp");
-               log(ERROR, "re-exec of %s failed. Waiting 0.2 seconds and trying again...", argv[0]);
+               log(ERROR, "re-exec of %s failed. Waiting 0.2 seconds and trying again...", argv0_canon);
                shut_down_logging();
                usleep(200000);
        }