/builddir/build/BUILD/libutil++-1.4.0/src/httpd.cpp

/*
** libutil++
** $Id: httpd.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Proprietary License. Do not distribute.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: httpd.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "test.h"

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

#include <mutex>
#include <condition_variable>

#include "alias.h"
#include "version.h"
#include "sella/util/Log.h"
#include "sella/util/String.h"
#include "sella/server/HTTP.h"
#include "sella/server/callbacks.h"
#include "sella/util/CommandLine.h"
#include "sella/net/IPAddressPort.h"

namespace sella {
        namespace httpd {
                bool running = true, restart = false;
                size_t workers = sella::server::HTTP::MinimumWorkersDefault;
                std::string listeners = "0.0.0.0:1080, [::]:1080"; // {IPAddressPort("0.0.0.0:1080"), IPAddressPort("[::]:1080") }
                std::string root = sella::server::HTTP::RootDefault;
                std::mutex mutex;
                std::condition_variable cv;
                enum Mode { NonBlock, Block, Async } mode = Block;
                int debug = 0;
        }
}

using namespace sella::httpd;
using namespace sella::util;
using namespace sella::net;
using namespace sella::server;

bool init_config(int argc, char **argv);
bool init_signals(void);
void sighandler(int sig);

bool acl_callback(HTTPConnection::shared connection) {
        return true;
}

bool authentication_callback(HTTPConnection::shared connection) {
        return true;
}

bool request_callback(HTTPConnection::shared connection) {
        return http::request_callback(connection); /* Passing to builtin as an example. */
}

bool error_callback(HTTPConnection::shared connection, int code, const std::string &detail = std::string()) {
        return http::error_callback(connection, code, detail); /* Passing to builtin as an example. */
}

int main(int argc, char **argv) {
        SET_FORMAT(SimpleLogFormat());
        SET_IDENTIFIER("httpd");
        SET_OPTION(Log::WithStderrOption);

        init_config(argc, argv);
        init_signals();

        INFO("Using %s v%s", libutilxx__package(), libutilxx__version());

        HTTP http;

        http.setListeners(listeners);
        http.setRoot(root);
        http.setCustomHeaders(std::vector<std::string>({ "X-Powered-By: unicorn tears", "Age: 0" }));

        /* Example of overriding builtin callbacks */
        http.setACLCallback(acl_callback);
        http.setAuthenticationCallback(authentication_callback);
        http.setRequestCallback(request_callback);
        http.setErrorCallback(error_callback);

        if (IS_TRACE("print")) {
                http.print();
        }

        try {
                while (running) {
                        std::unique_lock<std::mutex> lock(mutex);

                        INFO("Starting up on port(s): %s", http.getListenersString().c_str());

                        if (mode == Block) { 
                                http.run(workers);
                        } else if (mode == NonBlock) {
                                http.start(workers);

                                INFO("%s - Startup complete", http.getBanner().c_str());

                                while (running) {
                                        cv.wait(lock);
                                }

                                http.stop();
                        } else if (mode == Async) {
                                while (running) {
                                        http.receive();

                                        INFO("Doing something else...");
                                        usleep(500000);
                                }
                        } else {
                                WARNING("Guru Meditation #00000004.0000AAC0");

                                running = false;
                        }

                        if (restart) {
                                running = true;
                                restart = false;
                        }
                }

                INFO("%s - Shutdown complete", http.getBanner().c_str());
        } catch (ServerException &e) {
                INFO(e.what());

                return EXIT_FAILURE;
        }

        return EXIT_SUCCESS;
}

bool init_config(int argc, char **argv) {
        std::string m;
        sella::util::CommandLine cmdln(argc, argv);

        cmdln.add('m', "mode", "use MODE block, nonblock or async", "MODE", "block");
        cmdln.add('r', "root", "use DIR as root directory", "DIR", root);
        cmdln.add('l', "listeners", "use LIST as addresses/ports to listen", "LIST", listeners);
        cmdln.add('w', "workers", "use INT workers", "INT", workers, 1, 256);
        cmdln.add('d', "debug", "set debug level to INT", "INT", debug, 0, 9);
        cmdln.add();
        cmdln.add('h', "help", "display this help screen");
        cmdln.add('v', "version", "display version information");

        std::map<std::string, std::string>      conf = cmdln.parse(stdin);

        if (conf.find("help") != conf.end()) {
                printf("%s v%s\n", libutilxx__package(), libutilxx__version());
                cmdln.usage(stdout, EXIT_SUCCESS);
        } else if (conf.find("version") != conf.end()) {
                printf("%s v%s\n", libutilxx__package(), libutilxx__version());

                exit(EXIT_SUCCESS);
        }

        if (conf.find("mode") != conf.end()) {
                if (conf["mode"] == "block") {
                        mode = Block;
                } else if (conf["mode"] == "nonblock") {
                        mode = NonBlock;
                } else if (conf["mode"] == "async") {
                        mode = Async;
                }
        }

        if (conf.find("listeners") != conf.end()) {
                listeners = conf["listeners"];
        }

        if (conf.find("root") != conf.end()) {
                root = conf["root"];
        }

        if (conf.find("workers") != conf.end()) {
                workers = atoi(conf["workers"].c_str());
        }

        if (conf.find("debug") != conf.end()) {
                debug = atoi(conf["debug"].c_str());

                switch (debug) {
                        case 9:
                                SET_TRACE("all");
                                SET_LOGMASK(LOG_UPTO(LOG_DEBUG));

                        case 3:
                                SET_TRACE(PACKAGE "-detail");

                        case 2:
                                SET_TRACE(PACKAGE);

                        case 1:
                                SET_TRACE("print");
                }
        }

        return true;
}

bool init_signals(void) {
        struct sigaction act, old;

        act.sa_handler = sighandler;
        sigemptyset(&act.sa_mask);
        act.sa_flags = SA_RESTART;

        if (sigaction(SIGINT, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGINT.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGINT, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGINT.\n");
                }
        }

        if (sigaction(SIGTERM, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGTERM.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGTERM, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGTERM.\n");
                }
        }

        if (sigaction(SIGHUP, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGHUP.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGHUP, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGHUP.\n");
                }
        }

        if (sigaction(SIGUSR1, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGUSR1.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGUSR1, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGUSR1.\n");
                }
        }

        if (sigaction(SIGUSR2, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGUSR2.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGUSR2, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGUSR2.\n");
                }
        }

        if (sigaction(SIGPIPE, NULL, &old) < 0) { /* Prevents send() and write() on broken socket from terminating. */
                fprintf(stderr, "Failed to retrieve signal handler for SIGPIPE.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGPIPE, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGPIPE.\n");
                }
        }

        return true;
}

void sighandler(int sig) { /* Do not call syslog within handler. Will cause hangs/crash. */
        switch (sig) {
                case SIGINT:
                case SIGTERM:
                        running = false;
                        cv.notify_one();

                        break;

                case SIGHUP:
                        restart = true;
                        running = false;

                        break;

                case SIGUSR1:
                        break;

                case SIGUSR2:
                        break;

                case SIGPIPE:
                        break;

                default:
                        break;
        }
}

/*
** vim: noet ts=3 sw=3
*/

---