Cockatrice/servatrice/src/main.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Max-Wilhelm Bruker   *
 *   brukie@laptop   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "main.h"

#include "libcockatrice/rng/rng_abstract.h"
#include "servatrice.h"
#include "server_logger.h"
#include "settingscache.h"
#include "signalhandler.h"
#include "smtpclient.h"
#include "version_string.h"

#include <QCommandLineOption>
#include <QCommandLineParser>
#include <QCoreApplication>
#include <QDateTime>
#include <QDebug>
#include <QFile>
#include <QList>
#include <QMetaObject>
#include <QMetaType>
#include <QObject>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
#include <QThread>
#include <QVariant>
#include <QVector>
#include <cstdlib>
#include <google/protobuf/stubs/common.h>
#include <iostream>
#include <libcockatrice/rng/rng_sfmt.h>
#include <libcockatrice/utility/cryptoutil.h>
#include <libcockatrice/utility/passwordhasher.h>
#include <qlogging.h>
#include <qnamespace.h>
#include <string>

SignalHandler *signalhandler;

/* Prototypes */

void testRNG();
void testHash();
void myMessageOutput(QtMsgType type, const QMessageLogContext &, const QString &msg);
void myMessageOutput2(QtMsgType type, const QMessageLogContext &, const QString &msg);

/* Implementations */

void testRNG()
{
    const int n = 500000;
    std::cerr << "Testing random number generator (n = " << n << " * bins)..." << std::endl;

    const int min = 1;
    const int minMax = 2;
    const int maxMax = 10;

    QVector<QVector<int>> numbers(maxMax - minMax + 1);
    QVector<double> chisq(maxMax - minMax + 1);
    for (int max = minMax; max <= maxMax; ++max) {
        numbers[max - minMax] = rng->makeNumbersVector(n * (max - min + 1), min, max);
        chisq[max - minMax] = rng->testRandom(numbers[max - minMax]);
    }
    for (int i = 0; i <= maxMax - min; ++i) {
        std::cerr << (min + i);
        for (auto &number : numbers) {
            if (i < number.size()) {
                std::cerr << "\t" << number[i];
            } else {
                std::cerr << "\t";
            }
        }
        std::cerr << std::endl;
    }
    std::cerr << std::endl << "Chi^2 =";
    for (double j : chisq) {
        std::cerr << "\t" << QString::number(j, 'f', 3).toStdString();
    }
    std::cerr << std::endl << "k =";
    for (int j = 0; j < chisq.size(); ++j) {
        std::cerr << "\t" << (j - min + minMax);
    }
    std::cerr << std::endl << std::endl;
}

void testHash()
{
    const int n = 5000;
    std::cerr << "Benchmarking password hash function (n =" << n << ")..." << std::endl;
    QDateTime startTime = QDateTime::currentDateTime();
    for (int i = 0; i < n; ++i) {
        PasswordHasher::computeHash("aaaaaa", "aaaaaaaaaaaaaaaa");
    }
    QDateTime endTime = QDateTime::currentDateTime();
    std::cerr << startTime.secsTo(endTime) << "secs" << std::endl;
}

void myMessageOutput(QtMsgType /*type*/, const QMessageLogContext &, const QString &msg)
{
    logger->logMessage(msg);
}

void myMessageOutput2(QtMsgType /*type*/, const QMessageLogContext &, const QString &msg)
{
    logger->logMessage(msg);
    std::cerr << msg.toStdString() << std::endl;
}

namespace
{
void printEffectiveConfig(const SettingsCache &settings)
{
    for (const QString &key : settings.effectiveKeys()) {
        const QString rendered =
            SettingsCache::isSecretKey(key) ? QStringLiteral("<redacted>") : settings.value(key).toString();
        std::cout << key.toStdString() << '=' << rendered.toStdString() << '\n';
    }
}

bool applyConfigOverrides(SettingsCache &settings, const QStringList &values)
{
    for (const QString &entry : values) {
        QString key;
        QVariant value;
        if (!SettingsCache::parseOverride(entry, key, value)) {
            qCritical() << "Invalid --set value; expected a scalar key=value:" << entry;
            return false;
        }

        settings.setOverride(key, value);
    }

    if (!values.isEmpty()) {
        settings.rebuildDisallowedRegExps();
    }
    return true;
}
} // namespace

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    QCoreApplication::setOrganizationName("Cockatrice");
    QCoreApplication::setApplicationName("Servatrice");
    QCoreApplication::setApplicationVersion(VERSION_STRING);

    QCommandLineParser parser;
    parser.addHelpOption();
    parser.addVersionOption();

    QCommandLineOption testRandomOpt("test-random", "Test PRNG (chi^2)");
    parser.addOption(testRandomOpt);

    QCommandLineOption testHashFunctionOpt("test-hash", "Test password hash function");
    parser.addOption(testHashFunctionOpt);

    QCommandLineOption logToConsoleOpt("log-to-console", "Write server logs to console");
    parser.addOption(logToConsoleOpt);

    QCommandLineOption configPathOpt("config", "Read server configuration from <file>", "file", "");
    parser.addOption(configPathOpt);

    QCommandLineOption setConfigOpt(
        "set",
        "Override a section-qualified scalar configuration value for this run (key=value), such as "
        "server/port. May be repeated; bare keys and array keys such as rooms/roomlist/1/name are "
        "rejected; never writes the config file.",
        "key=value");
    parser.addOption(setConfigOpt);

    QCommandLineOption printConfigOpt("print-config", "Print the effective configuration and exit");
    parser.addOption(printConfigOpt);

    parser.process(app);

    bool testRandom = parser.isSet(testRandomOpt);
    bool testHashFunction = parser.isSet(testHashFunctionOpt);
    bool logToConsole = parser.isSet(logToConsoleOpt);
    QString configPath = parser.value(configPathOpt);

    qRegisterMetaType<QList<int>>("QList<int>");

    if (configPath.isEmpty()) {
        configPath = SettingsCache::guessConfigurationPath();
    } else if (!QFile::exists(configPath)) {
        qCritical() << "Could not find configuration file at" << configPath;
        return EXIT_FAILURE;
    }
    qWarning() << "Using configuration file: " << configPath;
    settingsCache = new SettingsCache(configPath);

    if (!applyConfigOverrides(*settingsCache, parser.values(setConfigOpt))) {
        return EXIT_FAILURE;
    }

    if (parser.isSet(printConfigOpt)) {
        printEffectiveConfig(*settingsCache);
        return EXIT_SUCCESS;
    }

    loggerThread = new QThread;
    loggerThread->setObjectName("logger");
    logger = new ServerLogger(logToConsole, settingsCache->value("server/writelog", 1).toBool(),
                              settingsCache->value("server/logfilters").toString());
    logger->moveToThread(loggerThread);

    loggerThread->start();
    QMetaObject::invokeMethod(logger, "startLog", Qt::BlockingQueuedConnection,
                              Q_ARG(QString, settingsCache->value("server/logfile", QString("server.log")).toString()));

    if (logToConsole) {
        qInstallMessageHandler(myMessageOutput);
    } else {
        qInstallMessageHandler(myMessageOutput2);
    }

    signalhandler = new SignalHandler();

    rng = new RNG_SFMT(CryptoUtil::randomUInt64());

    std::cerr << "Servatrice " << VERSION_STRING << " starting." << std::endl;
    std::cerr << "-------------------------" << std::endl;

    if (testRandom) {
        testRNG();
    }
    if (testHashFunction) {
        testHash();
    }
    if (testRandom || testHashFunction) {
        return 0;
    }

    smtpClient = new SmtpClient();

    auto *server = new Servatrice();
    QObject::connect(server, SIGNAL(destroyed()), &app, SLOT(quit()), Qt::QueuedConnection);
    int retval = 0;
    if (server->initServer()) {
        std::cerr << "-------------------------" << std::endl;
        std::cerr << "Server initialized." << std::endl;

        qInstallMessageHandler(myMessageOutput);

        retval = QCoreApplication::exec();

        std::cerr << "Server quit." << std::endl;
        std::cerr << "-------------------------" << std::endl;
    } else {
        // initServer() logged the reason; a failed startup must not look like a clean exit.
        std::cerr << "Server initialization failed, exiting." << std::endl;
        retval = EXIT_FAILURE;
    }

    // The handler reads the logger and settingsCache globals torn down below; leaving it
    // installed lets Qt's own shutdown warnings dereference freed memory.
    qInstallMessageHandler(nullptr);

    delete smtpClient;
    delete rng;
    delete signalhandler;
    delete settingsCache;

    logger->deleteLater();
    loggerThread->wait();
    delete loggerThread;

    // Delete all global objects allocated by libprotobuf.
    google::protobuf::ShutdownProtobufLibrary();

    QCoreApplication::quit();
    return retval;
}