X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fabstractsqlstorage.cpp;h=40a3bb04f260557bcfde2e7c920c84dd2e8e8485;hp=cb8fbd117faa2e586ca476e58692efe3bff378fa;hb=dd8c9291dd3308e7307a40ccb2a5d123e09b0915;hpb=436cb365db846985ef5ce508cb5bf925cd903480 diff --git a/src/core/abstractsqlstorage.cpp b/src/core/abstractsqlstorage.cpp index cb8fbd11..40a3bb04 100644 --- a/src/core/abstractsqlstorage.cpp +++ b/src/core/abstractsqlstorage.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2018 by the Quassel Project * + * Copyright (C) 2005-2019 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -19,9 +19,6 @@ ***************************************************************************/ #include "abstractsqlstorage.h" -#include "quassel.h" - -#include "logger.h" #include #include @@ -29,6 +26,9 @@ #include #include +#include "logmessage.h" +#include "quassel.h" + int AbstractSqlStorage::_nextConnectionId = 0; AbstractSqlStorage::AbstractSqlStorage(QObject *parent) : Storage(parent), @@ -116,9 +116,11 @@ void AbstractSqlStorage::dbConnect(QSqlDatabase &db) } -Storage::State AbstractSqlStorage::init(const QVariantMap &settings) +Storage::State AbstractSqlStorage::init(const QVariantMap &settings, + const QProcessEnvironment &environment, + bool loadFromEnvironment) { - setConnectionProperties(settings); + setConnectionProperties(settings, environment, loadFromEnvironment); _debug = Quassel::isOptionSet("debug"); @@ -137,11 +139,19 @@ Storage::State AbstractSqlStorage::init(const QVariantMap &settings) } if (installedSchemaVersion() < schemaVersion()) { - qWarning() << qPrintable(tr("Installed Schema (version %1) is not up to date. Upgrading to version %2...").arg(installedSchemaVersion()).arg(schemaVersion())); - if (!upgradeDb()) { + quInfo() << qPrintable(tr("Installed database schema (version %1) is not up to date. Upgrading to " + "version %2... This may take a while for major upgrades." + ).arg(installedSchemaVersion()).arg(schemaVersion())); + emit dbUpgradeInProgress(true); + auto upgradeResult = upgradeDb(); + emit dbUpgradeInProgress(false); + if (!upgradeResult) { qWarning() << qPrintable(tr("Upgrade failed...")); return NotAvailable; } + // Add a message when migration succeeds to avoid confusing folks by implying the schema upgrade failed if + // later functionality does not work. + quInfo() << qPrintable(tr("Installed database schema successfully upgraded to version %1.").arg(schemaVersion())); } quInfo() << qPrintable(displayName()) << "storage backend is ready. Schema version:" << installedSchemaVersion(); @@ -192,9 +202,10 @@ QStringList AbstractSqlStorage::setupQueries() } -bool AbstractSqlStorage::setup(const QVariantMap &settings) +bool AbstractSqlStorage::setup(const QVariantMap &settings, const QProcessEnvironment &environment, + bool loadFromEnvironment) { - setConnectionProperties(settings); + setConnectionProperties(settings, environment, loadFromEnvironment); QSqlDatabase db = logDb(); if (!db.isOpen()) { qCritical() << "Unable to setup Logging Backend!"; @@ -219,13 +230,13 @@ bool AbstractSqlStorage::setup(const QVariantMap &settings) } -QStringList AbstractSqlStorage::upgradeQueries(int version) +QList AbstractSqlStorage::upgradeQueries(int version) { - QStringList queries; + QList queries; // Upgrade queries are stored in the 'version/##' subfolders. QDir dir = QDir(QString(":/SQL/%1/version/%2/").arg(displayName()).arg(version)); foreach(QFileInfo fileInfo, dir.entryInfoList(QStringList() << "upgrade*", QDir::NoFilter, QDir::Name)) { - queries << queryString(fileInfo.baseName(), version); + queries << SqlQueryResource(queryString(fileInfo.baseName(), version), fileInfo.baseName()); } return queries; } @@ -238,16 +249,91 @@ bool AbstractSqlStorage::upgradeDb() QSqlDatabase db = logDb(); + // TODO: For databases that support it (e.g. almost only PostgreSQL), wrap upgrades in a + // transaction. This will need careful testing of potential additional space requirements and + // any database modifications that might not be allowed in a transaction. + + // Check if we're resuming an interrupted multi-step upgrade: is an upgrade step stored? + const QString previousLaunchUpgradeStep = schemaVersionUpgradeStep(); + bool resumingUpgrade = !previousLaunchUpgradeStep.isEmpty(); + for (int ver = installedSchemaVersion() + 1; ver <= schemaVersion(); ver++) { - foreach(QString queryString, upgradeQueries(ver)) { - QSqlQuery query = db.exec(queryString); + foreach (auto queryResource, upgradeQueries(ver)) { + if (resumingUpgrade) { + // An upgrade was interrupted. Check if this matches the the last successful query. + if (previousLaunchUpgradeStep == queryResource.queryFilename) { + // Found the matching query! + quInfo() << qPrintable(QString("Resuming interrupted upgrade for schema version %1 (last step: %2)") + .arg(QString::number(ver), previousLaunchUpgradeStep)); + + // Stop searching for queries + resumingUpgrade = false; + // Continue past the previous query with the next not-yet-tried query + continue; + } + else { + // Not yet matched, keep looking + continue; + } + } + + // Run the upgrade query + QSqlQuery query = db.exec(queryResource.queryString); if (!watchQuery(query)) { - qCritical() << "Unable to upgrade Logging Backend!"; + // Individual upgrade query failed, bail out + qCritical() << qPrintable(QString("Unable to upgrade Logging Backend! Upgrade query in schema version %1 failed (step: %2).") + .arg(QString::number(ver), queryResource.queryFilename)); return false; } + else { + // Mark as successful + setSchemaVersionUpgradeStep(queryResource.queryFilename); + } + } + + if (resumingUpgrade) { + // Something went wrong and the last successful SQL query to resume from couldn't be + // found. + // 1. The storage of successful query glitched, or the database was manually changed + // 2. Quassel changed the filenames of upgrade queries, and the local Quassel core + // version was replaced during an interrupted schema upgrade + // + // Both are unlikely, but it's a good idea to handle it anyways. + + qCritical() << qPrintable(QString("Unable to resume interrupted upgrade in Logging " + "Backend! Missing upgrade step in schema version %1 " + "(expected step: %2)") + .arg(QString::number(ver), previousLaunchUpgradeStep)); + return false; } + + // Update the schema version for each intermediate step and mark the step as done. This + // ensures that any interrupted upgrades have a greater chance of resuming correctly after + // core restart. + // + // Almost all databases make single queries atomic (fully works or fully fails, no partial), + // and with many of the longest migrations being a single query, this makes upgrade + // interruptions much more likely to leave the database in a valid intermediate schema + // version. + if (!updateSchemaVersion(ver, true)) { + // Updating the schema version failed, bail out + qCritical() << "Unable to upgrade Logging Backend! Setting schema version" + << ver << "failed."; + return false; + } + } + + // Update the schema version for the final step. Split this out to offer more informative + // logging (though setting schema version really should not fail). + if (!updateSchemaVersion(schemaVersion())) { + // Updating the final schema version failed, bail out + qCritical() << "Unable to upgrade Logging Backend! Setting final schema version" + << schemaVersion() << "failed."; + return false; } - return updateSchemaVersion(schemaVersion()); + + // If we made it here, everything seems to have worked! + return true; } @@ -277,6 +363,13 @@ int AbstractSqlStorage::schemaVersion() } +QString AbstractSqlStorage::schemaVersionUpgradeStep() +{ + // By default, assume there's no pending upgrade + return {}; +} + + bool AbstractSqlStorage::watchQuery(QSqlQuery &query) { bool queryError = query.lastError().isValid();