#include "quassel.h"
+#include <algorithm>
#include <iostream>
-#include <signal.h>
-#if !defined Q_OS_WIN && !defined Q_OS_MAC
-# include <sys/types.h>
-# include <sys/time.h>
-# include <sys/resource.h>
-#endif
#include <QCoreApplication>
#include <QDateTime>
#include "bufferinfo.h"
#include "identity.h"
#include "logger.h"
+#include "logmessage.h"
#include "message.h"
#include "network.h"
#include "peer.h"
#include "syncableobject.h"
#include "types.h"
-#include "../../version.h"
-
-Quassel *Quassel::instance()
-{
- static Quassel instance;
- return &instance;
-}
+#ifndef Q_OS_WIN
+# include "posixsignalwatcher.h"
+#else
+# include "windowssignalwatcher.h"
+#endif
+#include "../../version.h"
Quassel::Quassel()
+ : Singleton<Quassel>{this}
+ , _logger{new Logger{this}}
{
- // We catch SIGTERM and SIGINT (caused by Ctrl+C) to graceful shutdown Quassel.
- signal(SIGTERM, handleSignal);
- signal(SIGINT, handleSignal);
-#ifndef Q_OS_WIN
- // SIGHUP is used to reload configuration (i.e. SSL certificates)
- // Windows does not support SIGHUP
- signal(SIGHUP, handleSignal);
-#endif
}
-bool Quassel::init()
+void Quassel::init(RunMode runMode)
{
- if (instance()->_initialized)
- return true; // allow multiple invocations because of MonolithicApplication
-
- if (instance()->_handleCrashes) {
- // we have crashhandler for win32 and unix (based on execinfo).
-#if defined(Q_OS_WIN) || defined(HAVE_EXECINFO)
-# ifndef Q_OS_WIN
- // we only handle crashes ourselves if coredumps are disabled
- struct rlimit *limit = (rlimit *)malloc(sizeof(struct rlimit));
- int rc = getrlimit(RLIMIT_CORE, limit);
-
- if (rc == -1 || !((long)limit->rlim_cur > 0 || limit->rlim_cur == RLIM_INFINITY)) {
-# endif /* Q_OS_WIN */
- signal(SIGABRT, handleSignal);
- signal(SIGSEGV, handleSignal);
-# ifndef Q_OS_WIN
- signal(SIGBUS, handleSignal);
- }
- free(limit);
-# endif /* Q_OS_WIN */
-#endif /* Q_OS_WIN || HAVE_EXECINFO */
- }
+ _runMode = runMode;
- instance()->_initialized = true;
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
- instance()->setupEnvironment();
- instance()->registerMetaTypes();
+ setupSignalHandling();
+ setupEnvironment();
+ registerMetaTypes();
- Network::setDefaultCodecForServer("ISO-8859-1");
+ Network::setDefaultCodecForServer("UTF-8");
Network::setDefaultCodecForEncoding("UTF-8");
Network::setDefaultCodecForDecoding("ISO-8859-15");
if (isOptionSet("help")) {
instance()->_cliParser->usage();
- return false;
+ return;
}
if (isOptionSet("version")) {
std::cout << qPrintable("Quassel IRC: " + Quassel::buildInfo().plainVersionString) << std::endl;
- return false;
- }
-
- // set up logging
- if (Quassel::runMode() != Quassel::ClientOnly) {
- if (isOptionSet("loglevel")) {
- QString level = optionValue("loglevel");
-
- if (level == "Debug")
- setLogLevel(DebugLevel);
- else if (level == "Info")
- setLogLevel(InfoLevel);
- else if (level == "Warning")
- setLogLevel(WarningLevel);
- else if (level == "Error")
- setLogLevel(ErrorLevel);
- else {
- qWarning() << qPrintable(tr("Invalid log level %1; supported are Debug|Info|Warning|Error").arg(level));
- return false;
- }
- }
-
- QString logfilename = optionValue("logfile");
- if (!logfilename.isEmpty()) {
- instance()->_logFile.reset(new QFile{logfilename});
- if (!logFile()->open(QIODevice::Append | QIODevice::Text)) {
- qWarning() << "Could not open log file" << logfilename << ":" << logFile()->errorString();
- instance()->_logFile.reset();
- }
- }
-#ifdef HAVE_SYSLOG
- instance()->_logToSyslog = isOptionSet("syslog");
-#endif
+ return;
}
- return true;
+ // Don't keep a debug log on the core
+ logger()->setup(runMode != RunMode::CoreOnly);
}
-void Quassel::destroy()
+Logger *Quassel::logger() const
{
- if (logFile()) {
- logFile()->close();
- instance()->_logFile.reset();
- }
+ return _logger;
}
void Quassel::quit()
{
- if (_quitHandlers.empty()) {
- QCoreApplication::quit();
- }
- else {
- for (auto &&handler : _quitHandlers) {
- handler();
+ // Protect against multiple invocations (e.g. triggered by MainWin::closeEvent())
+ if (!_quitting) {
+ _quitting = true;
+ quInfo() << "Quitting...";
+ if (_quitHandlers.empty()) {
+ QCoreApplication::quit();
+ }
+ else {
+ // Note: We expect one of the registered handlers to call QCoreApplication::quit()
+ for (auto &&handler : _quitHandlers) {
+ handler();
+ }
}
}
}
// Check if we got a commit hash
if (!QString(GIT_HEAD).isEmpty()) {
buildInfo.commitHash = GIT_HEAD;
- QDateTime date;
- date.setTime_t(GIT_COMMIT_DATE);
- buildInfo.commitDate = date.toString();
+ // Set to Unix epoch, wrapped as a string for backwards-compatibility
+ buildInfo.commitDate = QString::number(GIT_COMMIT_DATE);
}
else if (!QString(DIST_HASH).contains("Format")) {
buildInfo.commitHash = DIST_HASH;
+ // Leave as Unix epoch if set as Unix epoch, but don't force this for
+ // backwards-compatibility with existing packaging/release tools that might set strings.
buildInfo.commitDate = QString(DIST_DATE);
}
}
-//! Signal handler for graceful shutdown.
-void Quassel::handleSignal(int sig)
+void Quassel::setupSignalHandling()
{
- switch (sig) {
- case SIGTERM:
- case SIGINT:
- qWarning("%s", qPrintable(QString("Caught signal %1 - exiting.").arg(sig)));
- instance()->quit();
- break;
#ifndef Q_OS_WIN
-// Windows does not support SIGHUP
- case SIGHUP:
- // Most applications use this as the 'configuration reload' command, e.g. nginx uses it for
- // graceful reloading of processes.
- quInfo() << "Caught signal" << SIGHUP << "- reloading configuration";
- if (instance()->reloadConfig()) {
- quInfo() << "Successfully reloaded configuration";
- }
- break;
-#endif
- case SIGABRT:
- case SIGSEGV:
-#ifndef Q_OS_WIN
- case SIGBUS:
+ _signalWatcher = new PosixSignalWatcher(this);
+#else
+ _signalWatcher = new WindowsSignalWatcher(this);
#endif
- instance()->logBacktrace(instance()->coreDumpFileName());
- exit(EXIT_FAILURE);
- default:
- ;
- }
+ connect(_signalWatcher, SIGNAL(handleSignal(AbstractSignalWatcher::Action)), this, SLOT(handleSignal(AbstractSignalWatcher::Action)));
}
-void Quassel::disableCrashHandler()
+void Quassel::handleSignal(AbstractSignalWatcher::Action action)
{
- instance()->_handleCrashes = false;
+ switch (action) {
+ case AbstractSignalWatcher::Action::Reload:
+ // Most applications use this as the 'configuration reload' command, e.g. nginx uses it for graceful reloading of processes.
+ if (!_reloadHandlers.empty()) {
+ quInfo() << "Reloading configuration";
+ if (reloadConfig()) {
+ quInfo() << "Successfully reloaded configuration";
+ }
+ }
+ break;
+ case AbstractSignalWatcher::Action::Terminate:
+ if (!_quitting) {
+ quit();
+ }
+ else {
+ quInfo() << "Already shutting down, ignoring signal";
+ }
+ break;
+ case AbstractSignalWatcher::Action::HandleCrash:
+ logBacktrace(instance()->coreDumpFileName());
+ exit(EXIT_FAILURE);
+ }
}
}
-void Quassel::setRunMode(RunMode runMode)
-{
- instance()->_runMode = runMode;
-}
-
-
void Quassel::setCliParser(std::shared_ptr<AbstractCliParser> parser)
{
instance()->_cliParser = std::move(parser);
}
-Quassel::LogLevel Quassel::logLevel()
-{
- return instance()->_logLevel;
-}
-
-
-void Quassel::setLogLevel(LogLevel logLevel)
-{
- instance()->_logLevel = logLevel;
-}
-
-
-QFile *Quassel::logFile() {
- return instance()->_logFile.get();
-}
-
-
-bool Quassel::logToSyslog()
-{
- return instance()->_logToSyslog;
-}
-
-
-void Quassel::logFatalMessage(const char *msg)
-{
-#ifdef Q_OS_MAC
- Q_UNUSED(msg)
-#else
- QFile dumpFile(instance()->coreDumpFileName());
- dumpFile.open(QIODevice::Append);
- QTextStream dumpStream(&dumpFile);
-
- dumpStream << "Fatal: " << msg << '\n';
- dumpStream.flush();
- dumpFile.close();
-#endif
-}
-
-
const QString &Quassel::coreDumpFileName()
{
if (_coreDumpFileName.isEmpty()) {
#endif /* Q_OS_MAC */
}
+ path = QFileInfo{path}.absoluteFilePath();
+
if (!path.endsWith(QDir::separator()) && !path.endsWith('/'))
path += QDir::separator();
}
instance()->_configDirPath = path;
-
return path;
}
-void Quassel::setDataDirPaths(const QStringList &paths) {
- instance()->_dataDirPaths = paths;
-}
-
-
QStringList Quassel::dataDirPaths()
{
- return instance()->_dataDirPaths;
-}
+ if (!instance()->_dataDirPaths.isEmpty())
+ return instance()->_dataDirPaths;
-
-QStringList Quassel::findDataDirPaths()
-{
- // TODO Qt5
- // We don't use QStandardPaths for now, as we still need to provide fallbacks for Qt4 and
- // want to stay consistent.
+ // TODO: Migrate to QStandardPaths (will require moving of the sqlite database,
+ // or a fallback for it being in the config dir)
QStringList dataDirNames;
#ifdef Q_OS_WIN
dataDirNames.removeDuplicates();
+ instance()->_dataDirPaths = dataDirNames;
return dataDirNames;
}
quasselTranslator->setObjectName("QuasselTr");
qApp->installTranslator(quasselTranslator);
-#if QT_VERSION >= 0x040800 && !defined Q_OS_MAC
+#ifndef Q_OS_MAC
bool success = qtTranslator->load(locale, QString("qt_"), translationDirPath());
if (!success)
qtTranslator->load(locale, QString("qt_"), QLibraryInfo::location(QLibraryInfo::TranslationsPath));
QStringList Quassel::Features::toStringList(bool enabled) const
{
+ // Check if any feature is enabled
+ if (!enabled && std::all_of(_features.cbegin(), _features.cend(), [](bool feature) { return !feature; })) {
+ return QStringList{} << "NoFeatures";
+ }
+
QStringList result;
+
// TODO Qt5: Use QMetaEnum::fromType()
auto featureEnum = Quassel::staticMetaObject.enumerator(Quassel::staticMetaObject.indexOfEnumerator("Feature"));
for (quint32 i = 0; i < _features.size(); ++i) {
projects / quassel.git / blobdiff