File indexing completed on 2025-01-05 04:46:57

 /*
     SPDX-FileCopyrightText: 2010 Tobias Koenig <tokoe@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "dbconfigpostgresql.h"
 #include "akonadiserver_debug.h"
 #include "utils.h"
 
 #include "private/standarddirs_p.h"
 #include "shared/akranges.h"
 
 #include <QDir>
 #include <QDirIterator>
 #include <QProcess>
 #include <QRegularExpression>
 #include <QRegularExpressionMatch>
 #include <QSqlDriver>
 #include <QSqlError>
 #include <QSqlQuery>
 #include <QStandardPaths>
 
 #include <config-akonadi.h>
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <chrono>
 #include <filesystem>
 
 using namespace std::chrono_literals;
 
 using namespace Akonadi;
 using namespace Akonadi::Server;
 using namespace AkRanges;
 
 namespace
 {
 
 const QString s_initConnection = QStringLiteral("initConnectionPsql");
 
 } // namespace
 
 DbConfigPostgresql::DbConfigPostgresql(const QString &configFile)
     : DbConfig(configFile)
 {
 }
 
 QString DbConfigPostgresql::driverName() const
 {
     return QStringLiteral("QPSQL");
 }
 
 QString DbConfigPostgresql::databaseName() const
 {
     return mDatabaseName;
 }
 
 QString DbConfigPostgresql::databasePath() const
 {
     return mPgData;
 }
 
 void DbConfigPostgresql::setDatabasePath(const QString &path, QSettings &settings)
 {
     mPgData = path;
     settings.beginGroup(driverName());
     settings.setValue(QStringLiteral("PgData"), mPgData);
     settings.endGroup();
     settings.sync();
 }
 
 namespace
 {
 struct VersionCompare {
     bool operator()(const QFileInfo &lhsFi, const QFileInfo &rhsFi) const
     {
         const auto lhs = parseVersion(lhsFi.fileName());
         if (!lhs.has_value()) {
             return false;
         }
         const auto rhs = parseVersion(rhsFi.fileName());
         if (!rhs.has_value()) {
             return true;
         }
 
         return std::tie(lhs->major, lhs->minor) < std::tie(rhs->major, rhs->minor);
     }
 
 private:
     struct Version {
         int major;
         int minor;
     };
     std::optional<Version> parseVersion(const QString &name) const
     {
         const auto dotIdx = name.indexOf(QLatin1Char('.'));
         if (dotIdx == -1) {
             return {};
         }
         bool ok = false;
         const auto major = QStringView(name).left(dotIdx).toInt(&ok);
         if (!ok) {
             return {};
         }
         const auto minor = QStringView(name).mid(dotIdx + 1).toInt(&ok);
         if (!ok) {
             return {};
         }
         return Version{major, minor};
     }
 };
 
 } // namespace
 
 QStringList DbConfigPostgresql::postgresSearchPaths(const QString &versionedPath) const
 {
     QStringList paths;
 
 #ifdef POSTGRES_PATH
     const QString dir(QStringLiteral(POSTGRES_PATH));
     if (QDir(dir).exists()) {
         paths.push_back(QStringLiteral(POSTGRES_PATH));
     }
 #endif
     paths << QStringLiteral("/usr/bin") << QStringLiteral("/usr/sbin") << QStringLiteral("/usr/local/sbin");
 
     // Locate all versions in /usr/lib/postgresql (i.e. /usr/lib/postgresql/X.Y) in reversed
     // sorted order, so we search from the newest one to the oldest.
     QDir versionedDir(versionedPath);
     if (versionedDir.exists()) {
         auto versionedDirs = versionedDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::NoSort);
         qDebug() << versionedDirs;
         std::sort(versionedDirs.begin(), versionedDirs.end(), VersionCompare());
         std::reverse(versionedDirs.begin(), versionedDirs.end());
         paths += versionedDirs | Views::transform([](const auto &dir) -> QString {
                      return dir.absoluteFilePath() + QStringLiteral("/bin");
                  })
             | Actions::toQList;
     }
 
     return paths;
 }
 
 bool DbConfigPostgresql::init(QSettings &settings, bool storeSettings, const QString &dbPathOverride)
 {
     // determine default settings depending on the driver
     QString defaultHostName;
     QString defaultOptions;
     QString defaultServerPath;
     QString defaultInitDbPath;
     QString defaultPgUpgradePath;
     QString defaultPgData;
 
 #ifndef Q_WS_WIN // We assume that PostgreSQL is running as service on Windows
     const bool defaultInternalServer = true;
 #else
     const bool defaultInternalServer = false;
 #endif
 
     mInternalServer = settings.value(QStringLiteral("QPSQL/StartServer"), defaultInternalServer).toBool();
     if (mInternalServer) {
         const auto paths = postgresSearchPaths(QStringLiteral("/usr/lib/postgresql"));
 
         defaultServerPath = QStandardPaths::findExecutable(QStringLiteral("pg_ctl"), paths);
         defaultInitDbPath = QStandardPaths::findExecutable(QStringLiteral("initdb"), paths);
         defaultHostName = Utils::preferredSocketDirectory(StandardDirs::saveDir("data", QStringLiteral("db_misc")));
         defaultPgUpgradePath = QStandardPaths::findExecutable(QStringLiteral("pg_upgrade"), paths);
         defaultPgData = dbPathOverride.isEmpty() ? StandardDirs::saveDir("data", QStringLiteral("db_data")) : dbPathOverride;
     }
 
     // read settings for current driver
     settings.beginGroup(driverName());
     mDatabaseName = settings.value(QStringLiteral("Name"), defaultDatabaseName()).toString();
     if (mDatabaseName.isEmpty()) {
         mDatabaseName = defaultDatabaseName();
     }
     mHostName = settings.value(QStringLiteral("Host"), defaultHostName).toString();
     if (mHostName.isEmpty()) {
         mHostName = defaultHostName;
     }
     mHostPort = settings.value(QStringLiteral("Port")).toInt();
     // User, password and Options can be empty and still valid, so don't override them
     mUserName = settings.value(QStringLiteral("User")).toString();
     mPassword = settings.value(QStringLiteral("Password")).toString();
     mConnectionOptions = settings.value(QStringLiteral("Options"), defaultOptions).toString();
     mServerPath = settings.value(QStringLiteral("ServerPath"), defaultServerPath).toString();
     if (mInternalServer && mServerPath.isEmpty()) {
         mServerPath = defaultServerPath;
     }
     qCDebug(AKONADISERVER_LOG) << "Found pg_ctl:" << mServerPath;
     mInitDbPath = settings.value(QStringLiteral("InitDbPath"), defaultInitDbPath).toString();
     if (mInternalServer && mInitDbPath.isEmpty()) {
         mInitDbPath = defaultInitDbPath;
     }
     qCDebug(AKONADISERVER_LOG) << "Found initdb:" << mServerPath;
     mPgUpgradePath = settings.value(QStringLiteral("UpgradePath"), defaultPgUpgradePath).toString();
     if (mInternalServer && mPgUpgradePath.isEmpty()) {
         mPgUpgradePath = defaultPgUpgradePath;
     }
     qCDebug(AKONADISERVER_LOG) << "Found pg_upgrade:" << mPgUpgradePath;
     mPgData = settings.value(QStringLiteral("PgData"), defaultPgData).toString();
     if (mPgData.isEmpty()) {
         mPgData = defaultPgData;
     }
     settings.endGroup();
 
     if (storeSettings) {
         // store back the default values
         settings.beginGroup(driverName());
         settings.setValue(QStringLiteral("Name"), mDatabaseName);
         settings.setValue(QStringLiteral("Host"), mHostName);
         if (mHostPort) {
             settings.setValue(QStringLiteral("Port"), mHostPort);
         }
         settings.setValue(QStringLiteral("Options"), mConnectionOptions);
         settings.setValue(QStringLiteral("ServerPath"), mServerPath);
         settings.setValue(QStringLiteral("InitDbPath"), mInitDbPath);
         settings.setValue(QStringLiteral("StartServer"), mInternalServer);
         settings.setValue(QStringLiteral("PgData"), mPgData);
         settings.endGroup();
         settings.sync();
     }
 
     return true;
 }
 
 bool DbConfigPostgresql::isAvailable(QSettings &settings)
 {
     if (!QSqlDatabase::drivers().contains(driverName())) {
         return false;
     }
 
     if (!init(settings, false)) {
         return false;
     }
 
     if (mInternalServer) {
         if (mInitDbPath.isEmpty() || !QFile::exists(mInitDbPath)) {
             return false;
         }
 
         if (mServerPath.isEmpty() || !QFile::exists(mServerPath)) {
             return false;
         }
     }
 
     return true;
 }
 
 void DbConfigPostgresql::apply(QSqlDatabase &database)
 {
     if (!mDatabaseName.isEmpty()) {
         database.setDatabaseName(mDatabaseName);
     }
     if (!mHostName.isEmpty()) {
         database.setHostName(mHostName);
     }
     if (mHostPort > 0 && mHostPort < 65535) {
         database.setPort(mHostPort);
     }
     if (!mUserName.isEmpty()) {
         database.setUserName(mUserName);
     }
     if (!mPassword.isEmpty()) {
         database.setPassword(mPassword);
     }
 
     database.setConnectOptions(mConnectionOptions);
 
     // can we check that during init() already?
     Q_ASSERT(database.driver()->hasFeature(QSqlDriver::LastInsertId));
 }
 
 bool DbConfigPostgresql::useInternalServer() const
 {
     return mInternalServer;
 }
 
 std::optional<DbConfigPostgresql::Versions> DbConfigPostgresql::checkPgVersion() const
 {
     // Contains major version of Postgres that created the cluster
     QFile pgVersionFile(QStringLiteral("%1/PG_VERSION").arg(mPgData));
     if (!pgVersionFile.open(QIODevice::ReadOnly)) {
         return std::nullopt;
     }
     const auto clusterVersion = pgVersionFile.readAll().toInt();
 
     QProcess pgctl;
     pgctl.start(mServerPath, {QStringLiteral("--version")}, QIODevice::ReadOnly);
     if (!pgctl.waitForFinished()) {
         return std::nullopt;
     }
     // Looks like "pg_ctl (PostgreSQL) 11.2"
     const auto output = QString::fromUtf8(pgctl.readAll());
 
     // Get the major version from major.minor
     QRegularExpression re(QStringLiteral("\\(PostgreSQL\\) ([0-9]+).[0-9]+"));
     const auto match = re.match(output);
     if (!match.hasMatch()) {
         return std::nullopt;
     }
     const auto serverVersion = match.captured(1).toInt();
 
     qDebug(AKONADISERVER_LOG) << "Detected psql versions - cluster:" << clusterVersion << ", server:" << serverVersion;
     return {{clusterVersion, serverVersion}};
 }
 
 bool DbConfigPostgresql::runInitDb(const QString &newDbPath)
 {
     // Make sure the cluster directory exists
     if (!QDir(newDbPath).exists()) {
         if (!QDir().mkpath(newDbPath)) {
             return false;
         }
     }
 
 #ifdef Q_OS_LINUX
     // It is recommended to disable CoW feature when running on Btrfs to improve
     // database performance. This only has effect when done on empty directory,
     // so we only call this before calling initdb
     if (Utils::getDirectoryFileSystem(newDbPath) == QLatin1StringView("btrfs")) {
         Utils::disableCoW(newDbPath);
     }
 #endif
 
     // call 'initdb --pgdata=/home/user/.local/share/akonadi/data_db'
     return execute(mInitDbPath, {QStringLiteral("--pgdata=%1").arg(newDbPath), QStringLiteral("--encoding=UTF8"), QStringLiteral("--no-locale")}) == 0;
 }
 
 namespace
 {
 std::optional<QString> findBinPathForVersion(int version)
 {
     // First we need to find where the previous PostgreSQL version binaries are available
     const auto oldBinSearchPaths = {
         QStringLiteral("/usr/lib64/pgsql/postgresql-%1/bin").arg(version), // Fedora & friends
         QStringLiteral("/usr/lib/pgsql/postgresql-%1/bin").arg(version),
         QStringLiteral("/usr/lib/postgresql/%1/bin").arg(version), // Debian-based
         QStringLiteral("/opt/pgsql-%1/bin").arg(version), // Arch Linux
         // TODO: Check other distros as well, they might do things differently.
     };
 
     for (const auto &path : oldBinSearchPaths) {
         if (QDir(path).exists()) {
             return path;
         }
     }
 
     return std::nullopt;
 }
 
 bool checkAndRemoveTmpCluster(const QDir &baseDir, const QString &clusterName)
 {
     if (baseDir.exists(clusterName)) {
         qCInfo(AKONADISERVER_LOG) << "Postgres cluster update:" << clusterName << "cluster already exists, trying to remove it first";
         if (!QDir(baseDir.path() + QDir::separator() + clusterName).removeRecursively()) {
             qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: failed to remove" << clusterName
                                          << "cluster from some previous run, not performing auto-upgrade";
             return false;
         }
     }
     return true;
 }
 
 bool runPgUpgrade(const QString &pgUpgrade,
                   const QDir &baseDir,
                   const QString &oldBinPath,
                   const QString &newBinPath,
                   const QString &oldDbData,
                   const QString &newDbData)
 {
     QProcess process;
     const QStringList args = {QString(QStringLiteral("--old-bindir=%1").arg(oldBinPath)),
                               QString(QStringLiteral("--new-bindir=%1").arg(newBinPath)),
                               QString(QStringLiteral("--old-datadir=%1").arg(oldDbData)),
                               QString(QStringLiteral("--new-datadir=%1").arg(newDbData))};
     qCInfo(AKONADISERVER_LOG) << "Postgres cluster update: starting pg_upgrade to upgrade your Akonadi DB cluster";
     qCDebug(AKONADISERVER_LOG) << "Executing pg_upgrade" << QStringList(args);
     process.setWorkingDirectory(baseDir.path());
     process.start(pgUpgrade, args);
     process.waitForFinished(std::chrono::milliseconds(1h).count());
     if (process.exitCode() != 0) {
         qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: pg_upgrade finished with exit code" << process.exitCode()
                                      << ", please run migration manually.";
         return false;
     }
 
     qCDebug(AKONADISERVER_LOG) << "Postgres cluster update: pg_upgrade finished successfully.";
     return true;
 }
 
 bool swapClusters(QDir &baseDir, const QString &oldDbDataCluster, const QString &newDbDataCluster)
 {
     // If everything went fine, swap the old and new clusters
     if (!baseDir.rename(QStringLiteral("db_data"), oldDbDataCluster)) {
         qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: failed to rename old db_data to" << oldDbDataCluster;
         return false;
     }
     if (!baseDir.rename(newDbDataCluster, QStringLiteral("db_data"))) {
         qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: failed to rename" << newDbDataCluster << "to db_data, rolling back";
         if (!baseDir.rename(oldDbDataCluster, QStringLiteral("db_data"))) {
             qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: failed to roll back from" << oldDbDataCluster << "to db_data.";
             return false;
         }
         qCDebug(AKONADISERVER_LOG) << "Postgres cluster update: rollback successful.";
         return false;
     }
 
     return true;
 }
 
 } // namespace
 
 bool DbConfigPostgresql::upgradeCluster(int clusterVersion)
 {
     const auto oldDbDataCluster = QStringLiteral("old_db_data");
     const auto newDbDataCluster = QStringLiteral("new_db_data");
 
     QDir baseDir(mPgData); // db_data
     baseDir.cdUp(); // move to its parent folder
 
     const auto oldBinPath = findBinPathForVersion(clusterVersion);
     if (!oldBinPath.has_value()) {
         qCDebug(AKONADISERVER_LOG) << "Postgres cluster update: failed to find Postgres server for version" << clusterVersion;
         return false;
     }
     const auto newBinPath = QFileInfo(mServerPath).path();
 
     if (!checkAndRemoveTmpCluster(baseDir, oldDbDataCluster)) {
         return false;
     }
     if (!checkAndRemoveTmpCluster(baseDir, newDbDataCluster)) {
         return false;
     }
 
     // Next, initialize a new cluster
     const QString newDbData = baseDir.path() + QDir::separator() + newDbDataCluster;
     qCInfo(AKONADISERVER_LOG) << "Postgres cluster upgrade: creating a new cluster for current Postgres server";
     if (!runInitDb(newDbData)) {
         qCWarning(AKONADISERVER_LOG) << "Postgres cluster update: failed to initialize new db cluster";
         return false;
     }
 
     // Now migrate the old cluster from the old version into the new cluster
     if (!runPgUpgrade(mPgUpgradePath, baseDir, *oldBinPath, newBinPath, mPgData, newDbData)) {
         return false;
     }
 
     if (!swapClusters(baseDir, oldDbDataCluster, newDbDataCluster)) {
         return false;
     }
 
     // Drop the old cluster
     if (!QDir(baseDir.path() + QDir::separator() + oldDbDataCluster).removeRecursively()) {
         qCInfo(AKONADISERVER_LOG) << "Postgres cluster update: failed to remove" << oldDbDataCluster << "cluster (not an issue, continuing)";
     }
 
     return true;
 }
 
 bool DbConfigPostgresql::startInternalServer()
 {
     // We defined the mHostName to the socket directory, during init
     const QString socketDir = mHostName;
     bool success = true;
 
     // Make sure the path exists, otherwise pg_ctl fails
     if (!QFile::exists(socketDir)) {
         QDir().mkpath(socketDir);
     }
 
 // TODO Windows support
 #ifndef Q_WS_WIN
     // If postmaster.pid exists, check whether the postgres process still exists too,
     // because normally we shouldn't be able to get this far if Akonadi is already
     // running. If postgres is not running, then the pidfile was left after a system
     // crash or something similar and we can remove it (otherwise pg_ctl won't start)
     QFile postmaster(QStringLiteral("%1/postmaster.pid").arg(mPgData));
     if (postmaster.exists() && postmaster.open(QIODevice::ReadOnly)) {
         qCDebug(AKONADISERVER_LOG) << "Found a postmaster.pid pidfile, checking whether the server is still running...";
         QByteArray pid = postmaster.readLine();
         // Remove newline character
         pid.chop(1);
         QFile proc(QString::fromLatin1("/proc/" + pid + "/stat"));
         // Check whether the process with the PID from pidfile still exists and whether
         // it's actually still postgres or, whether the PID has been recycled in the
         // meanwhile.
         if (proc.open(QIODevice::ReadOnly)) {
             const QByteArray stat = proc.readAll();
             const QList<QByteArray> stats = stat.split(' ');
             if (stats.count() > 1) {
                 // Make sure the PID actually belongs to postgres process
                 if (stats[1] == "(postgres)") {
                     // Yup, our PostgreSQL is actually running, so pretend we started the server
                     // and try to connect to it
                     qCWarning(AKONADISERVER_LOG) << "PostgreSQL for Akonadi is already running, trying to connect to it.";
                     return true;
                 }
             }
             proc.close();
         }
 
         qCDebug(AKONADISERVER_LOG) << "No postgres process with specified PID is running. Removing the pidfile and starting a new Postgres instance...";
         postmaster.close();
         postmaster.remove();
     }
 #endif
 
     // postgres data directory not initialized yet, so call initdb on it
     if (!QFile::exists(QStringLiteral("%1/PG_VERSION").arg(mPgData))) {
 #ifdef Q_OS_LINUX
         // It is recommended to disable CoW feature when running on Btrfs to improve
         // database performance. This only has effect when done on an empty directory,
         // so we call this before calling initdb.
         if (Utils::getDirectoryFileSystem(mPgData) == QLatin1StringView("btrfs")) {
             Utils::disableCoW(mPgData);
         }
 #endif
         // call 'initdb --pgdata=/home/user/.local/share/akonadi/db_data'
         execute(mInitDbPath, {QStringLiteral("--pgdata=%1").arg(mPgData), QStringLiteral("--encoding=UTF8"), QStringLiteral("--no-locale")});
     } else {
         const auto versions = checkPgVersion();
         if (versions.has_value() && (versions->clusterVersion < versions->pgServerVersion)) {
             qCInfo(AKONADISERVER_LOG) << "Cluster PG_VERSION is" << versions->clusterVersion << ", PostgreSQL server is version " << versions->pgServerVersion
                                       << ", will attempt to upgrade the cluster";
             if (upgradeCluster(versions->clusterVersion)) {
                 qCInfo(AKONADISERVER_LOG) << "Successfully upgraded db cluster from Postgres" << versions->clusterVersion << "to" << versions->pgServerVersion;
             } else {
                 qCWarning(AKONADISERVER_LOG) << "Postgres db cluster upgrade failed, Akonadi will fail to start. Sorry.";
             }
         }
     }
 
     // synthesize the postgres command
     QStringList arguments;
     arguments << QStringLiteral("start") << QStringLiteral("-w") << QStringLiteral("--timeout=10") // default is 60 seconds.
               << QStringLiteral("--pgdata=%1").arg(mPgData)
               // These options are passed to postgres
               //  -k - directory for unix domain socket communication
               //  -h - disable listening for TCP/IP
               << QStringLiteral("-o \"-k%1\" -h ''").arg(socketDir);
 
     qCDebug(AKONADISERVER_LOG) << "Executing:" << mServerPath << arguments.join(QLatin1Char(' '));
     QProcess pgCtl;
     pgCtl.start(mServerPath, arguments);
     if (!pgCtl.waitForStarted()) {
         qCCritical(AKONADISERVER_LOG) << "Could not start database server!";
         qCCritical(AKONADISERVER_LOG) << "executable:" << mServerPath;
         qCCritical(AKONADISERVER_LOG) << "arguments:" << arguments;
         qCCritical(AKONADISERVER_LOG) << "process error:" << pgCtl.errorString();
         return false;
     }
 
     {
         QSqlDatabase db = QSqlDatabase::addDatabase(QStringLiteral("QPSQL"), s_initConnection);
         apply(db);
 
         // use the default database that is always available
         db.setDatabaseName(QStringLiteral("postgres"));
 
         if (!db.isValid()) {
             qCCritical(AKONADISERVER_LOG) << "Invalid database object during database server startup";
             return false;
         }
 
         bool opened = false;
         for (int i = 0; i < 120; ++i) {
             opened = db.open();
             if (opened) {
                 break;
             }
 
             if (pgCtl.waitForFinished(500) && pgCtl.exitCode()) {
                 qCCritical(AKONADISERVER_LOG) << "Database process exited unexpectedly during initial connection!";
                 qCCritical(AKONADISERVER_LOG) << "executable:" << mServerPath;
                 qCCritical(AKONADISERVER_LOG) << "arguments:" << arguments;
                 qCCritical(AKONADISERVER_LOG) << "stdout:" << pgCtl.readAllStandardOutput();
                 qCCritical(AKONADISERVER_LOG) << "stderr:" << pgCtl.readAllStandardError();
                 qCCritical(AKONADISERVER_LOG) << "exit code:" << pgCtl.exitCode();
                 qCCritical(AKONADISERVER_LOG) << "process error:" << pgCtl.errorString();
                 return false;
             }
         }
 
         if (opened) {
             {
                 QSqlQuery query(db);
 
                 // check if the 'akonadi' database already exists
                 query.exec(QStringLiteral("SELECT 1 FROM pg_catalog.pg_database WHERE datname = '%1'").arg(mDatabaseName));
 
                 // if not, create it
                 if (!query.first()) {
                     if (!query.exec(QStringLiteral("CREATE DATABASE %1").arg(mDatabaseName))) {
                         qCCritical(AKONADISERVER_LOG) << "Failed to create database";
                         qCCritical(AKONADISERVER_LOG) << "Query error:" << query.lastError().text();
                         qCCritical(AKONADISERVER_LOG) << "Database error:" << db.lastError().text();
                         success = false;
                     }
                 }
             } // make sure query is destroyed before we close the db
             db.close();
         }
     }
     // Make sure pg_ctl has returned
     pgCtl.waitForFinished();
 
     QSqlDatabase::removeDatabase(s_initConnection);
     return success;
 }
 
 void DbConfigPostgresql::stopInternalServer()
 {
     if (!checkServerIsRunning()) {
         qCDebug(AKONADISERVER_LOG) << "Database is no longer running";
         return;
     }
 
     // first, try a FAST shutdown
     execute(mServerPath, {QStringLiteral("stop"), QStringLiteral("--pgdata=%1").arg(mPgData), QStringLiteral("--mode=fast")});
     if (!checkServerIsRunning()) {
         return;
     }
 
     // second, try an IMMEDIATE shutdown
     execute(mServerPath, {QStringLiteral("stop"), QStringLiteral("--pgdata=%1").arg(mPgData), QStringLiteral("--mode=immediate")});
     if (!checkServerIsRunning()) {
         return;
     }
 
     // third, pg_ctl couldn't terminate all the postgres processes, we have to
     // kill the master one. We don't want to do that, but we've passed the last
     // call. pg_ctl is used to send the kill signal (safe when kill is not
     // supported by OS)
     const QString pidFileName = QStringLiteral("%1/postmaster.pid").arg(mPgData);
     QFile pidFile(pidFileName);
     if (pidFile.open(QIODevice::ReadOnly)) {
         QString postmasterPid = QString::fromUtf8(pidFile.readLine(0).trimmed());
         qCCritical(AKONADISERVER_LOG) << "The postmaster is still running. Killing it.";
 
         execute(mServerPath, {QStringLiteral("kill"), QStringLiteral("ABRT"), postmasterPid});
     }
 }
 
 bool DbConfigPostgresql::checkServerIsRunning()
 {
     const QString command = mServerPath;
     QStringList arguments;
     arguments << QStringLiteral("status") << QStringLiteral("--pgdata=%1").arg(mPgData);
 
     QProcess pgCtl;
     pgCtl.start(command, arguments, QIODevice::ReadOnly);
     if (!pgCtl.waitForFinished(3000)) {
         // Error?
         return false;
     }
 
     // "pg_ctl status" exits with 0 when server is running and a non-zero code when not.
     return pgCtl.exitCode() == 0;
 }
 
 bool DbConfigPostgresql::disableConstraintChecks(const QSqlDatabase &db)
 {
     for (const auto &table : db.tables()) {
         qCDebug(AKONADISERVER_LOG) << "Disabling triggers on table" << table;
         QSqlQuery query(db);
         if (!query.exec(QStringLiteral("ALTER TABLE %1 DISABLE TRIGGER ALL").arg(table))) {
             qCWarning(AKONADISERVER_LOG) << "Failed to disable triggers on table" << table << ":" << query.lastError().databaseText();
             enableConstraintChecks(db);
             return false;
         }
     }
 
     return true;
 }
 
 bool DbConfigPostgresql::enableConstraintChecks(const QSqlDatabase &db)
 {
     for (const auto &table : db.tables()) {
         qCDebug(AKONADISERVER_LOG) << "Enabling triggers on table" << table;
         QSqlQuery query(db);
         if (!query.exec(QStringLiteral("ALTER TABLE %1 ENABLE TRIGGER ALL").arg(table))) {
             qCWarning(AKONADISERVER_LOG) << "Failed to enable triggers on table" << table << ":" << query.lastError().databaseText();
             // continue
         }
     }
 
     return true;
 }