920 lines
34 KiB
C++
Executable File
920 lines
34 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* DBUpdate
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Iuliana Ojog, 2021-02-17
|
|
*/
|
|
|
|
#include "db_update.h"
|
|
#include "ui_db_update.h"
|
|
#include "show_history.h"
|
|
|
|
#include <ngldb/dbconnection.h>
|
|
#include <ngldb/dbtransaction.h>
|
|
#include <ngldb/nsqlquery.h>
|
|
#include <nglsettings/nglsettings_settings.h>
|
|
#include <ngltools/ngltools_filesystem.h>
|
|
|
|
#include <QMessageBox>
|
|
#include <QDateTime>
|
|
#include <QDir>
|
|
#include <QFileDialog>
|
|
#include <QSqlError>
|
|
|
|
namespace DBUpdate
|
|
{
|
|
QString DBUpdate::m_defaultPath = QDir::homePath() + QStringLiteral("/bin/updates/");
|
|
|
|
DBUpdate::DBUpdate(QWidget *parent)
|
|
: QMainWindow(parent)
|
|
, m_ui(new Ui::DBUpdate)
|
|
, m_showHistory(new ShowHistory)
|
|
, m_logger(getLogger("DBUpdate"))
|
|
{
|
|
m_ui->setupUi(this);
|
|
|
|
setWindowTitle(QLatin1String("Database Update"));
|
|
|
|
m_globalUpdatesModel = new GlobalUpdatesModel(this);
|
|
m_globalUpdatesProxyModel = new GlobalUpdatesProxyModel(this);
|
|
m_globalUpdatesProxyModel->setSourceModel(m_globalUpdatesModel);
|
|
m_ui->tvGlobalUpdates->setModel(m_globalUpdatesProxyModel);
|
|
connect(m_ui->tvGlobalUpdates, &QTableView::doubleClicked, this, &DBUpdate::onShowGlobalHistory);
|
|
|
|
m_exercisesModel = new ExercisesModel(this);
|
|
m_exercisesProxyModel = new ExercisesProxyModel(this);
|
|
m_exercisesProxyModel->setSourceModel(m_exercisesModel);
|
|
m_ui->tvExerciseUpdates->setModel(m_exercisesProxyModel);
|
|
connect(m_ui->tvExerciseUpdates, &QTableView::doubleClicked, this, &DBUpdate::onShowExerciseHistory);
|
|
|
|
connect(m_ui->tbClose, &QToolButton::clicked, this, &DBUpdate::onClosedClicked);
|
|
connect(m_ui->tbLoadUpdate, &QToolButton::clicked, this, &DBUpdate::onUpdateLoad);
|
|
connect(m_ui->tbRunUpdate, &QToolButton::clicked, this, &DBUpdate::onUpdateRun);
|
|
connect(m_ui->tbShowLog, &QToolButton::clicked, this, &DBUpdate::onShowLogFile);
|
|
connect(m_ui->tbClearLog, &QToolButton::clicked, this, &DBUpdate::onClearLogFile);
|
|
connect(m_ui->tbLoadSQL, &QToolButton::clicked, this, &DBUpdate::onLoadSQL);
|
|
connect(m_ui->tbBackup, &QToolButton::clicked, this, &DBUpdate::onBackupDB);
|
|
|
|
m_ui->tvExerciseUpdates->hideColumn(ExercisesModel::Columns::Id);
|
|
m_ui->tvExerciseUpdates->hideColumn(ExercisesModel::Columns::StartTime);
|
|
m_ui->tvExerciseUpdates->hideColumn(ExercisesModel::Columns::EndTime);
|
|
//m_ui->tvExerciseUpdates->hideColumn(ExercisesModel::Columns::StateId);
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
DBUpdate::~DBUpdate()
|
|
{
|
|
delete m_showHistory;
|
|
delete m_globalUpdatesModel;
|
|
delete m_globalUpdatesProxyModel;
|
|
delete m_exercisesModel;
|
|
delete m_exercisesProxyModel;
|
|
delete m_ui;
|
|
}
|
|
|
|
bool DBUpdate::init()
|
|
{
|
|
QString str;
|
|
NGL::Settings s(str);
|
|
|
|
// open postgres db, read table structure, read static data
|
|
const QString dbUser(QStringLiteral("postgres"));
|
|
const QString dbPasswd(QStringLiteral("postgres"));
|
|
m_db = DBConnection::open(m_logger,
|
|
dbUser,
|
|
dbPasswd,
|
|
s.databaseDriver(),
|
|
s.databaseHostname(),
|
|
s.databaseName());
|
|
if (!m_db.isOpen())
|
|
return false;
|
|
|
|
m_ui->lblDbConnection->setText(m_db.hostName() + QStringLiteral(" / ") + m_db.databaseName());
|
|
enaDisa();
|
|
|
|
return true;
|
|
}
|
|
|
|
void DBUpdate::onClosedClicked()
|
|
{
|
|
close();
|
|
}
|
|
|
|
void DBUpdate::onUpdateLoad()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onUpdateLoad";
|
|
|
|
// open dialog
|
|
const QStringList filter(
|
|
{
|
|
tr("Update Files (*.upd)"),
|
|
#ifdef Q_OS_WIN
|
|
tr("All (*.*)")
|
|
#else
|
|
tr("All (*)")
|
|
#endif
|
|
});
|
|
|
|
QString fileName = QFileDialog::getOpenFileName(this,
|
|
tr("Load database update file"),
|
|
m_defaultPath,
|
|
filter.join(QStringLiteral(";;")));
|
|
if (fileName.isEmpty())
|
|
return;
|
|
|
|
QFileInfo fileInfo(fileName);
|
|
if (!fileInfo.isReadable())
|
|
{
|
|
QMessageBox::warning(this, tr("Error!"), tr("An error occurred while loading the file.\n"
|
|
"The loaded file is not readable."));
|
|
return;
|
|
}
|
|
|
|
m_defaultPath = fileInfo.path() + QLatin1Char('/');
|
|
m_update.filename = fileName;
|
|
|
|
if (parseUpdateFile(fileName))
|
|
{
|
|
m_globalUpdatesModel->initModel(m_db, m_update.version, m_update.global_schemas.split(QStringLiteral(",")));
|
|
m_exercisesModel->initModel(m_db, m_update.version, m_update.exercise_schemas.split(QStringLiteral(",")));
|
|
m_ui->tbRunUpdate->setEnabled(true);
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << "Not a valid update file " << fileName;
|
|
}
|
|
|
|
void DBUpdate::onUpdateRun()
|
|
{
|
|
QStringList gSchemas = m_globalUpdatesModel->getSchemasToUpdate();
|
|
QStringList eSchemas = m_exercisesModel->getSchemasToUpdate();
|
|
|
|
// generate SQL
|
|
m_sql.clear();
|
|
if (m_update.global_sql.size() > 0 && gSchemas.size() > 0)
|
|
{
|
|
for (auto &gs : gSchemas)
|
|
{
|
|
m_sql += QStringLiteral("--BEGIN;\n");
|
|
if (gs != QStringLiteral("PUBLIC"))
|
|
{
|
|
QString sUser = QStringLiteral("ets_") + gs;
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT SELECT,INSERT,UPDATE,DELETE,TRUNCATE ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT SELECT, REFERENCES ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT EXECUTE ON FUNCTIONS TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT ALL ON SEQUENCES TO ") + sUser + QStringLiteral(";\n");
|
|
}
|
|
m_sql += QStringLiteral("SET SEARCH_PATH TO %1;\n").arg(gs);
|
|
m_sql += m_update.global_sql;
|
|
m_sql += QStringLiteral("\n");
|
|
m_sql += QStringLiteral("INSERT INTO db_version (description, version) VALUES ('%1', '%2');\n\n").arg(m_update.info, m_update.version);
|
|
m_sql += QStringLiteral("\n--COMMIT;\n\n");
|
|
}
|
|
}
|
|
if (m_update.exercise_sql.size() > 0 && eSchemas.size() > 0)
|
|
{
|
|
for (auto &es : eSchemas)
|
|
{
|
|
m_sql += QStringLiteral("--BEGIN;\n");
|
|
QString sUser = QStringLiteral("ets_ex_00"); // + es;
|
|
|
|
m_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
m_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
m_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
|
|
// backwards compatibility
|
|
QString sOldUser = QStringLiteral("ets_") + es;
|
|
m_sql += QStringLiteral("SELECT public.revoke_user_if_exists('%1','%2');\n").arg(sOldUser).arg(es);
|
|
/*
|
|
m_sql += QStringLiteral("SELECT create_user_if_not_exists('%1');\n").arg(sOldUser);
|
|
m_sql += QStringLiteral("REVOKE ALL PRIVILEGES ON ALL TABLES IN SCHEMA %1 FROM %2 CASCADE;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("REVOKE ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA %1 FROM %2 CASCADE;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON TABLES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON TABLES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON FUNCTIONS FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON FUNCTIONS FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON SEQUENCES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON SEQUENCES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_sql += QStringLiteral("DROP USER %1;\n").arg(sOldUser);
|
|
*/
|
|
// backwards compatibility
|
|
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT SELECT,INSERT,UPDATE,DELETE,TRUNCATE ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT SELECT, REFERENCES ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT EXECUTE ON FUNCTIONS TO ") + sUser + QStringLiteral(";\n");
|
|
m_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT ALL ON SEQUENCES TO ") + sUser + QStringLiteral(";\n");
|
|
|
|
m_sql += QStringLiteral("SET SEARCH_PATH TO %1;\n").arg(es);
|
|
m_sql += m_update.exercise_sql;
|
|
m_sql += QStringLiteral("\n");
|
|
m_sql += QStringLiteral("INSERT INTO db_version (description, version) VALUES ('%1', '%2');\n\n").arg(m_update.info, m_update.version);
|
|
m_sql += QStringLiteral("\n--COMMIT;\n\n");
|
|
}
|
|
}
|
|
|
|
if (m_sql.size() > 0)
|
|
{
|
|
saveUpdateSql();
|
|
|
|
DBTransaction transaction(m_db);
|
|
NSqlQuery q(m_db);
|
|
|
|
transaction.begin();
|
|
|
|
if (!q.exec(m_sql))
|
|
{
|
|
DEBUG_LOG(m_logger) << "Failed sql: " << m_sql;
|
|
ERROR_LOG(m_logger) << "Error running sql: " << q.lastError().databaseText() << " " << q.lastError().driverText();
|
|
transaction.rollback();
|
|
if (m_showUi)
|
|
QMessageBox::warning(this, tr("Error!"), tr("An error occurred executing sql. See log file for details."));
|
|
}
|
|
else
|
|
{
|
|
transaction.commit();
|
|
if (transaction.state())
|
|
{
|
|
DEBUG_LOG(m_logger) << "SUCCESS running update: " << m_update.filename;
|
|
if (m_showUi)
|
|
QMessageBox::information(this, tr("Success"), tr("Update successful!"));
|
|
}
|
|
else
|
|
{
|
|
transaction.rollback();
|
|
if (m_showUi)
|
|
QMessageBox::warning(this, tr("Error!"), tr("An error occurred executing sql. See log file for details."));
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
if (m_showUi)
|
|
QMessageBox::warning(this, tr("Warning"), tr("Nothing to update."));
|
|
|
|
if (m_showUi)
|
|
enaDisa();
|
|
}
|
|
|
|
void DBUpdate::saveUpdateSql()
|
|
{
|
|
QString sqlFile = DBUpdate::m_defaultPath + m_update.version;
|
|
if (m_update.project.size() > 0)
|
|
sqlFile += QStringLiteral("_") + m_update.project;
|
|
sqlFile += QStringLiteral("_run.sql");
|
|
|
|
QFile file(sqlFile);
|
|
if (!file.open(QIODevice::WriteOnly | QFile::Truncate))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error opening file '" << file.fileName() << "' for writing: "
|
|
<< file.errorString();
|
|
return ;
|
|
}
|
|
|
|
file.write(m_sql.toUtf8());
|
|
file.write("\n");
|
|
|
|
file.close();
|
|
|
|
INFO_LOG(m_logger) << "Saved GENERATED UPDATE FILE: " << sqlFile;
|
|
|
|
return;
|
|
}
|
|
|
|
void DBUpdate::onBackupDB()
|
|
{
|
|
INFO_LOG(m_logger) << "Creating DB Backup";
|
|
|
|
const QString& gVers = m_globalUpdatesModel->getLastUpdate();
|
|
const QString& eVers = m_exercisesModel->getLastUpdate();
|
|
|
|
QString currVersion = ( gVers >= eVers ? gVers : eVers );
|
|
QString date = QDate::currentDate().toString(QLatin1String("yyyyMMdd"));
|
|
|
|
QString dumpFile = DBUpdate::m_defaultPath + m_db.hostName() + QLatin1Char('_') +
|
|
m_db.databaseName()+ QLatin1Char('_') + date + QLatin1Char('_') + currVersion + QStringLiteral(".dump");
|
|
|
|
DBUpdateRun *dbRun = new DBUpdateRun(QString(), false, true);
|
|
bool backupOK = dbRun->runPgDump(dumpFile, m_db.hostName(), m_db.databaseName());
|
|
if (!backupOK)
|
|
{
|
|
ERROR_LOG(m_logger) << "Backup failed";
|
|
QMessageBox::critical(this, tr("Backup"), tr("Backup failed!"), QMessageBox::Ok);
|
|
}
|
|
else
|
|
{
|
|
INFO_LOG(m_logger) << "Created DB Backup successfully: " << dumpFile;
|
|
QMessageBox::information(this, tr("Backup"), tr("Successfully created DB backup: %1").arg(dumpFile), QMessageBox::Ok);
|
|
}
|
|
delete dbRun;
|
|
|
|
}
|
|
|
|
void DBUpdate::enaDisa()
|
|
{
|
|
if (!m_ui)
|
|
return;
|
|
|
|
// reset UI
|
|
m_globalUpdatesModel->initModel(m_db);
|
|
m_exercisesModel->initModel(m_db);
|
|
m_ui->tbRunUpdate->setEnabled(false);
|
|
m_ui->lblSelectedUpdate->setText(tr("(no update loaded)"));
|
|
m_ui->teHeader->clear();
|
|
m_ui->lblSQL->clear();
|
|
m_ui->pteSQL->clear();
|
|
|
|
m_ui->tvExerciseUpdates->resizeColumnsToContents();
|
|
m_ui->tvGlobalUpdates->resizeColumnsToContents();
|
|
|
|
const QString& gVers = m_globalUpdatesModel->getLastUpdate();
|
|
const QString& eVers = m_exercisesModel->getLastUpdate();
|
|
|
|
int upperGVersion = gVers.split(QLatin1Char('.')).at(0).toInt();
|
|
int gVersion = gVers.section(QLatin1Char('.'), 1).toInt();
|
|
DEBUG_LOG(m_logger) << "gVersion: " << gVersion;
|
|
DEBUG_LOG(m_logger) << "upperGVersion: " << upperGVersion;
|
|
|
|
int upperEVersion = eVers.split(QLatin1Char('.')).at(0).toInt();
|
|
int eVersion = eVers.section(QLatin1Char('.'), 1).toInt();
|
|
DEBUG_LOG(m_logger) << "eVersion: " << eVersion;
|
|
DEBUG_LOG(m_logger) << "upperEVersion: " << upperEVersion;
|
|
|
|
QString currVersion = eVers;
|
|
if ( upperGVersion > upperEVersion )
|
|
currVersion = gVers;
|
|
else if ( upperGVersion == upperEVersion )
|
|
currVersion = (gVersion >= eVersion ? gVers : eVers );
|
|
|
|
m_ui->lblVersion->setText(currVersion);
|
|
}
|
|
|
|
void DBUpdate::onShowLogFile()
|
|
{
|
|
QString logFile = NGL::Settings::logPath() + QStringLiteral("/") + QString::fromLatin1(qgetenv("USER")) + QStringLiteral("_dbu.log");
|
|
DEBUG_LOG(m_logger) << "onShowLogFile(): " << logFile;
|
|
|
|
QFile file(logFile);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot open file " << logFile;
|
|
return ;
|
|
}
|
|
|
|
QByteArray output = file.readAll();
|
|
|
|
m_ui->pteLogFile->clear();
|
|
m_ui->pteLogFile->setPlainText(QString::fromLocal8Bit(output));
|
|
|
|
file.close();
|
|
return;
|
|
}
|
|
|
|
void DBUpdate::onClearLogFile()
|
|
{
|
|
QString logFile = NGL::Settings::logPath() + QStringLiteral("/") + QString::fromLatin1(qgetenv("USER")) + QStringLiteral("_dbu.log");
|
|
DEBUG_LOG(m_logger) << "onClearLogFile(): " << logFile;
|
|
|
|
QFile file(logFile);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QFile::Truncate))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot clear file " << logFile;
|
|
return ;
|
|
}
|
|
|
|
file.close();
|
|
m_ui->pteLogFile->clear();
|
|
|
|
return;
|
|
}
|
|
|
|
bool DBUpdate::parseUpdateFile(const QString &fileName, bool showUi)
|
|
{
|
|
DEBUG_LOG(m_logger) << "parseUpdateFile: " << fileName;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot read file " << fileName;
|
|
return false;
|
|
}
|
|
|
|
QByteArray fileContent = file.readAll();
|
|
QString updateFile = QString::fromLocal8Bit(fileContent);
|
|
|
|
QStringList strUpdate;
|
|
bool fileOk = true;
|
|
|
|
static const QRegularExpression re_info(QStringLiteral("INFO: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_date(QStringLiteral("DATE: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_vers(QStringLiteral("VERSION: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_proj(QStringLiteral("PROJECT: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_glob(QStringLiteral("GLOBAL: (.+?);.(.+?COMMIT;)"), QRegularExpression::DotMatchesEverythingOption);
|
|
static const QRegularExpression re_exer(QStringLiteral("EXERCISE: (.+?);.(.+?COMMIT;)"), QRegularExpression::DotMatchesEverythingOption);
|
|
|
|
QRegularExpressionMatch match_info = re_info.match(updateFile);
|
|
QRegularExpressionMatch match_proj = re_proj.match(updateFile);
|
|
QRegularExpressionMatch match_vers = re_vers.match(updateFile);
|
|
QRegularExpressionMatch match_date = re_date.match(updateFile);
|
|
QRegularExpressionMatch match_glob = re_glob.match(updateFile);
|
|
QRegularExpressionMatch match_exer = re_exer.match(updateFile);
|
|
if (match_info.hasMatch() && match_vers.hasMatch() && match_glob.hasMatch() && match_exer.hasMatch())
|
|
// these are mandatory for a valid update file
|
|
{
|
|
strUpdate += match_info.captured(0);
|
|
strUpdate += match_vers.captured(0);
|
|
if (match_date.hasMatch())
|
|
{
|
|
strUpdate += match_date.captured(0);
|
|
m_update.date = match_date.captured(1);
|
|
}
|
|
if (match_proj.hasMatch())
|
|
{
|
|
strUpdate += match_proj.captured(0);
|
|
m_update.project = match_proj.captured(1).toLower();
|
|
}
|
|
|
|
strUpdate += QStringLiteral("GLOBAL: ") + match_glob.captured(1);
|
|
strUpdate += QStringLiteral("EXERCISE: ") + match_exer.captured(1);
|
|
|
|
m_update.info = match_info.captured(1);
|
|
m_update.version = match_vers.captured(1);
|
|
ERROR_LOG(m_logger) << "Update version: " << m_update.version;
|
|
|
|
m_update.global_schemas = match_glob.captured(1);
|
|
m_update.global_sql = match_glob.captured(2);
|
|
m_update.exercise_schemas = match_exer.captured(1);
|
|
m_update.exercise_sql = match_exer.captured(2);
|
|
|
|
m_update.global_sql.remove(QStringLiteral("BEGIN;"));
|
|
m_update.global_sql.remove(QStringLiteral("COMMIT;"));
|
|
m_update.exercise_sql.remove(QStringLiteral("BEGIN;"));
|
|
m_update.exercise_sql.remove(QStringLiteral("COMMIT;"));
|
|
}
|
|
else
|
|
{
|
|
fileOk = false;
|
|
}
|
|
|
|
if (fileOk && showUi)
|
|
{
|
|
m_ui->lblSelectedUpdate->setText(fileName);
|
|
m_ui->teHeader->clear();
|
|
m_ui->teHeader->setText(strUpdate.join(QStringLiteral("\n")));
|
|
DEBUG_LOG(m_logger) << " teHeader strUpdate: " << strUpdate.join(QStringLiteral("\n"));
|
|
}
|
|
|
|
file.close();
|
|
|
|
return fileOk;
|
|
}
|
|
|
|
void DBUpdate::onShowGlobalHistory(const QModelIndex &idx)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onShowHistory";
|
|
QModelIndex realIdx = m_globalUpdatesProxyModel->mapToSource(idx);
|
|
const QString &schema = m_globalUpdatesModel->getRowData(realIdx.row()).schema;
|
|
|
|
DEBUG_LOG(m_logger) << "Schema = " << schema;
|
|
|
|
if (m_showHistory->init(m_db, schema))
|
|
m_showHistory->show();
|
|
}
|
|
|
|
void DBUpdate::onShowExerciseHistory(const QModelIndex &idx)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onShowHistory";
|
|
QModelIndex realIdx = m_exercisesProxyModel->mapToSource(idx);
|
|
const QString &schema = m_exercisesModel->getRowData(realIdx.row()).schema;
|
|
|
|
DEBUG_LOG(m_logger) << "Schema = " << schema;
|
|
|
|
if (m_showHistory->init(m_db, schema))
|
|
m_showHistory->show();
|
|
}
|
|
|
|
void DBUpdate::onLoadSQL()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onLoadSQL";
|
|
|
|
// open dialog
|
|
const QStringList filter(
|
|
{
|
|
tr("Update Files (*.sql)"),
|
|
#ifdef Q_OS_WIN
|
|
tr("All (*.*)")
|
|
#else
|
|
tr("All (*)")
|
|
#endif
|
|
});
|
|
|
|
QString fileName = QFileDialog::getOpenFileName(this,
|
|
tr("Load sql file"),
|
|
m_defaultPath,
|
|
filter.join(QStringLiteral(";;")));
|
|
if (fileName.isEmpty())
|
|
return;
|
|
|
|
QFileInfo fileInfo(fileName);
|
|
if (!fileInfo.isReadable())
|
|
{
|
|
QMessageBox::warning(this, tr("Error!"), tr("An error occurred while loading the file.\n"
|
|
"The loaded file is not readable."));
|
|
return;
|
|
}
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot open file " << fileName;
|
|
return ;
|
|
}
|
|
|
|
QByteArray output = file.readAll();
|
|
|
|
m_ui->lblSQL->setText(fileName);
|
|
m_ui->pteSQL->clear();
|
|
m_ui->pteSQL->setPlainText(QString::fromLocal8Bit(output));
|
|
|
|
file.close();
|
|
}
|
|
|
|
//===============================================================================================
|
|
DBUpdateRun::DBUpdateRun(const QString &updateFile, bool generateOnly, bool withBackup, QObject *parent)
|
|
: QObject(parent)
|
|
, m_generateOnly(generateOnly)
|
|
, m_withBackup(withBackup)
|
|
, m_globalUpdatesModel(new GlobalUpdatesModel(this))
|
|
, m_exercisesModel(new ExercisesModel(this))
|
|
, m_proc(nullptr)
|
|
, m_logger(getLogger("DBUpdate"))
|
|
{
|
|
m_update.filename = updateFile;
|
|
}
|
|
|
|
DBUpdateRun::~DBUpdateRun()
|
|
{
|
|
delete m_globalUpdatesModel;
|
|
delete m_exercisesModel;
|
|
}
|
|
|
|
bool DBUpdateRun::init()
|
|
{
|
|
QString str;
|
|
NGL::Settings s(str);
|
|
|
|
// open postgres db, read table structure, read static data
|
|
const QString dbUser(QStringLiteral("postgres"));
|
|
const QString dbPasswd(QStringLiteral("postgres"));
|
|
m_db = DBConnection::open(m_logger,
|
|
dbUser,
|
|
dbPasswd,
|
|
s.databaseDriver(),
|
|
s.databaseHostname(),
|
|
s.databaseName());
|
|
if (!m_db.isOpen())
|
|
return false;
|
|
|
|
DEBUG_LOG(m_logger) << "DB Open: " << s.databaseHostname() << " / " << s.databaseName();
|
|
|
|
m_globalUpdatesModel->initModel(m_db);
|
|
m_exercisesModel->initModel(m_db);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DBUpdateRun::runUpdate()
|
|
{
|
|
DEBUG_LOG(m_logger) << "runUpdate: " << m_update.filename;
|
|
bool bRet = false;
|
|
|
|
if (m_withBackup)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Creating DB Backup ...";
|
|
|
|
const QString& gVers = m_globalUpdatesModel->getLastUpdate();
|
|
const QString& eVers = m_exercisesModel->getLastUpdate();
|
|
|
|
QString currVersion = ( gVers >= eVers ? gVers : eVers );
|
|
|
|
QString dumpFile = DBUpdate::m_defaultPath + m_db.hostName() + QLatin1Char('_') +
|
|
m_db.databaseName()+ QLatin1Char('_') + currVersion + QStringLiteral(".dump");
|
|
|
|
if (!runPgDump(dumpFile, m_db.hostName(), m_db.databaseName()))
|
|
ERROR_LOG(m_logger) << "DB Backup failed!!!";
|
|
}
|
|
|
|
if (parseUpdateFile())
|
|
{
|
|
DEBUG_LOG(m_logger) << "succesfully parsed update file:" << m_update.filename;
|
|
|
|
m_globalUpdatesModel->initModel(m_db, m_update.version, m_update.global_schemas.split(QStringLiteral(",")));
|
|
m_exercisesModel->initModel(m_db, m_update.version, m_update.exercise_schemas.split(QStringLiteral(",")));
|
|
|
|
generateSql();
|
|
|
|
if (m_update.generated_file.size() > 0)
|
|
bRet = true;
|
|
|
|
if (!m_generateOnly && bRet)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Running sql file: " << m_update.generated_file;
|
|
bRet = runPsql();
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool DBUpdateRun::runPsql()
|
|
{
|
|
const QStringList args({QStringLiteral("-U"),
|
|
QStringLiteral("postgres"),
|
|
QStringLiteral("-f"),
|
|
m_update.generated_file,
|
|
QStringLiteral("-h"),
|
|
m_db.hostName(),
|
|
m_db.databaseName()});
|
|
|
|
handleProcInit(executablePath(QStringLiteral("psql")), args);
|
|
connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
|
|
this, &DBUpdateRun::onPsqlFinished);
|
|
m_proc->start();
|
|
return m_proc->waitForFinished();
|
|
}
|
|
|
|
bool DBUpdateRun::runPgDump(const QString& dumpFile, const QString& dbHost, const QString& dbName)
|
|
{
|
|
INFO_LOG(m_logger) << "Backup file = " << dumpFile;
|
|
|
|
const QStringList args(
|
|
{ QStringLiteral("--column-inserts"),
|
|
QStringLiteral("-U"), QStringLiteral("postgres"),
|
|
QStringLiteral("-f"), dumpFile,
|
|
QStringLiteral("-h"), dbHost, dbName});
|
|
|
|
handleProcInit(executablePath(QStringLiteral("pg_dump")), args);
|
|
connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
|
|
this, &DBUpdateRun::onPgDumpFinished);
|
|
m_proc->start();
|
|
return m_proc->waitForFinished();
|
|
}
|
|
|
|
QString DBUpdateRun::executablePath(const QString &program)
|
|
{
|
|
QString errStr;
|
|
const QString ret = NGL::postgresExecutablePath(program, errStr);
|
|
if (!errStr.isEmpty())
|
|
WARNING_LOG(m_logger) << errStr;
|
|
return ret;
|
|
}
|
|
|
|
void DBUpdateRun::handleProcInit(const QString &program, const QStringList &args)
|
|
{
|
|
if (m_proc)
|
|
{
|
|
m_proc->disconnect(this);
|
|
m_proc->deleteLater();
|
|
}
|
|
m_proc = new QProcess(this);
|
|
NOTICE_LOG(m_logger) << "Starting process '" << program << "' with args '" << args.join(QLatin1Char(' ')) << "'";
|
|
m_proc->setProgram(program);
|
|
m_proc->setArguments(args);
|
|
connect(m_proc, &QProcess::errorOccurred,
|
|
this, &DBUpdateRun::onErrorOccured);
|
|
}
|
|
|
|
void DBUpdateRun::handleProcFinished(int exitCode, QProcess::ExitStatus exitStatus)
|
|
{
|
|
if (!m_proc)
|
|
return;
|
|
if (exitCode != 0 || exitStatus != 0)
|
|
{
|
|
QByteArray out = m_proc->readAllStandardError();
|
|
if (!out.isEmpty())
|
|
out += '\n';
|
|
out += m_proc->readAllStandardOutput();
|
|
ERROR_LOG(m_logger) << "Process finished - exitCode: " << exitCode << ", exitStatus = " << exitStatus << ", " << out;
|
|
}
|
|
m_proc->disconnect(this);
|
|
m_proc->deleteLater();
|
|
m_proc = nullptr;
|
|
}
|
|
|
|
void DBUpdateRun::onPsqlFinished(int exitCode, QProcess::ExitStatus exitStatus)
|
|
{
|
|
NOTICE_LOG(m_logger) << "onPsqlFinished: exitCode: " << exitCode << ", exitStatus: " << exitStatus;
|
|
|
|
if (exitCode > 0)
|
|
{
|
|
ERROR_LOG(m_logger) << "Psql failed";
|
|
emit runSqlFailed();
|
|
return;
|
|
}
|
|
emit runSqlFinished();
|
|
}
|
|
|
|
void DBUpdateRun::onPgDumpFinished(int exitCode, QProcess::ExitStatus exitStatus)
|
|
{
|
|
NOTICE_LOG(m_logger) << "onPgDumpFinished: exitCode: " << exitCode << ", exitStatus: " << exitStatus;
|
|
|
|
if (exitCode > 0)
|
|
{
|
|
ERROR_LOG(m_logger) << "Backup (pg_dump) failed";
|
|
emit runPgDumpFailed();
|
|
return;
|
|
}
|
|
ERROR_LOG(m_logger) << "Backup successfully finished!";
|
|
emit runPgDumpFinished();
|
|
}
|
|
|
|
void DBUpdateRun::onErrorOccured(QProcess::ProcessError error)
|
|
{
|
|
ERROR_LOG(m_logger) << "error: " << error << ", " << m_proc->readAllStandardOutput() << ", " << m_proc->readAllStandardError();
|
|
}
|
|
|
|
bool DBUpdateRun::parseUpdateFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "parseUpdateFile: " << m_update.filename;
|
|
|
|
QFile file(m_update.filename);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot read file " << m_update.filename;
|
|
return false;
|
|
}
|
|
|
|
QByteArray fileContent = file.readAll();
|
|
QString updateFile = QString::fromLocal8Bit(fileContent);
|
|
|
|
QStringList strUpdate;
|
|
bool fileOk = true;
|
|
|
|
static const QRegularExpression re_info(QStringLiteral("INFO: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_date(QStringLiteral("DATE: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_vers(QStringLiteral("VERSION: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_proj(QStringLiteral("PROJECT: (.*?)$"), QRegularExpression::MultilineOption);
|
|
static const QRegularExpression re_glob(QStringLiteral("GLOBAL: (.+?);.(.+?COMMIT;)"), QRegularExpression::DotMatchesEverythingOption);
|
|
static const QRegularExpression re_exer(QStringLiteral("EXERCISE: (.+?);.(.+?COMMIT;)"), QRegularExpression::DotMatchesEverythingOption);
|
|
|
|
QRegularExpressionMatch match_info = re_info.match(updateFile);
|
|
QRegularExpressionMatch match_vers = re_vers.match(updateFile);
|
|
QRegularExpressionMatch match_date = re_date.match(updateFile);
|
|
QRegularExpressionMatch match_glob = re_glob.match(updateFile);
|
|
QRegularExpressionMatch match_exer = re_exer.match(updateFile);
|
|
QRegularExpressionMatch match_proj = re_proj.match(updateFile);
|
|
|
|
if (match_info.hasMatch() && match_vers.hasMatch() && match_glob.hasMatch() && match_exer.hasMatch())
|
|
// these are mandatory for a valid update file
|
|
{
|
|
strUpdate += match_info.captured(0);
|
|
strUpdate += match_vers.captured(0);
|
|
if (match_date.hasMatch())
|
|
{
|
|
strUpdate += match_date.captured(0);
|
|
m_update.date = match_date.captured(1);
|
|
}
|
|
if (match_proj.hasMatch())
|
|
{
|
|
strUpdate += match_proj.captured(0);
|
|
m_update.project = match_proj.captured(1).toLower();
|
|
}
|
|
|
|
strUpdate += QStringLiteral("GLOBAL: ") + match_glob.captured(1);
|
|
strUpdate += QStringLiteral("EXERCISE: ") + match_exer.captured(1);
|
|
|
|
m_update.info = match_info.captured(1);
|
|
m_update.version = match_vers.captured(1);
|
|
m_update.global_schemas = match_glob.captured(1);
|
|
m_update.global_sql = match_glob.captured(2);
|
|
m_update.exercise_schemas = match_exer.captured(1);
|
|
m_update.exercise_sql = match_exer.captured(2);
|
|
|
|
m_update.global_sql.remove(QStringLiteral("BEGIN;"));
|
|
m_update.global_sql.remove(QStringLiteral("COMMIT;"));
|
|
m_update.exercise_sql.remove(QStringLiteral("BEGIN;"));
|
|
m_update.exercise_sql.remove(QStringLiteral("COMMIT;"));
|
|
}
|
|
else
|
|
{
|
|
fileOk = false;
|
|
}
|
|
|
|
file.close();
|
|
|
|
return fileOk;
|
|
}
|
|
|
|
void DBUpdateRun::generateSql()
|
|
{
|
|
DEBUG_LOG(m_logger) << "generateSql:";
|
|
|
|
QStringList gSchemas = m_globalUpdatesModel->getSchemasToUpdate();
|
|
QStringList eSchemas = m_exercisesModel->getSchemasToUpdate();
|
|
|
|
DEBUG_LOG(m_logger) << "Global schemas: " << gSchemas.join(QStringLiteral(","));
|
|
DEBUG_LOG(m_logger) << "Exercise schemas: " << gSchemas.join(QStringLiteral(","));
|
|
|
|
DEBUG_LOG(m_logger) << "Global sql: " << m_update.global_sql;
|
|
DEBUG_LOG(m_logger) << "Exercise sql: " << m_update.exercise_sql;
|
|
|
|
// generate SQL
|
|
m_update.generated_sql.clear();
|
|
if (m_update.global_sql.size() > 0 && gSchemas.size() > 0)
|
|
{
|
|
ERROR_LOG(m_logger) << "Global sql: " << m_update.global_sql;
|
|
|
|
for (auto &gs : gSchemas)
|
|
{
|
|
m_update.generated_sql += QStringLiteral("--BEGIN;\n");
|
|
if (gs != QStringLiteral("PUBLIC"))
|
|
{
|
|
QString sUser = QStringLiteral("ets_") + gs;
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT SELECT,INSERT,UPDATE,DELETE,TRUNCATE ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT SELECT, REFERENCES ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT EXECUTE ON FUNCTIONS TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + gs + QStringLiteral(" GRANT ALL ON SEQUENCES TO ") + sUser + QStringLiteral(";\n");
|
|
}
|
|
}
|
|
m_update.generated_sql += QStringLiteral("SET SEARCH_PATH TO %1;\n").arg(gSchemas.join(QStringLiteral(",")));
|
|
m_update.generated_sql += m_update.global_sql;
|
|
m_update.generated_sql += QStringLiteral("\n");
|
|
m_update.generated_sql += QStringLiteral("INSERT INTO db_version (description, version) VALUES ('%1', '%2');\n\n").arg(m_update.info, m_update.version);
|
|
m_update.generated_sql += QStringLiteral("\n--COMMIT;\n\n");
|
|
}
|
|
if (m_update.exercise_sql.size() > 0 && eSchemas.size() > 0)
|
|
{
|
|
ERROR_LOG(m_logger) << "Exercise sql: " << m_update.exercise_sql;
|
|
|
|
for (auto &es : eSchemas)
|
|
{
|
|
m_update.generated_sql += QStringLiteral("--BEGIN;\n");
|
|
QString sUser = QStringLiteral("ets_ex_00"); // + es;
|
|
|
|
m_update.generated_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
m_update.generated_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
m_update.generated_sql += QStringLiteral("GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA %1 TO %2;\n").arg(es).arg(sUser);
|
|
|
|
//backwards compatibility
|
|
QString sOldUser = QStringLiteral("ets_") + es;
|
|
m_update.generated_sql += QStringLiteral("SELECT public.revoke_user_if_exists('%1','%2');\n").arg(sOldUser).arg(es);
|
|
/*
|
|
m_update.generated_sql += QStringLiteral("SELECT create_user_if_not_exists('%1');\n").arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("REVOKE ALL PRIVILEGES ON ALL TABLES IN SCHEMA %1 FROM %2 CASCADE;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("REVOKE ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA %1 FROM %2 CASCADE;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON TABLES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON TABLES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON FUNCTIONS FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON FUNCTIONS FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA %1 REVOKE ALL ON SEQUENCES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES FOR ROLE ets_exm IN SCHEMA %1 REVOKE ALL ON SEQUENCES FROM %2;\n").arg(es).arg(sOldUser);
|
|
m_update.generated_sql += QStringLiteral("DROP USER %1;\n").arg(sOldUser);
|
|
*/
|
|
//backwards compatibility
|
|
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT SELECT,INSERT,UPDATE,DELETE,TRUNCATE ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT SELECT, REFERENCES ON TABLES TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT EXECUTE ON FUNCTIONS TO ") + sUser + QStringLiteral(";\n");
|
|
m_update.generated_sql += QStringLiteral("ALTER DEFAULT PRIVILEGES IN SCHEMA ") + es + QStringLiteral(" GRANT ALL ON SEQUENCES TO ") + sUser + QStringLiteral(";\n");
|
|
|
|
m_update.generated_sql += QStringLiteral("SET SEARCH_PATH TO %1;\n").arg(es);
|
|
m_update.generated_sql += m_update.exercise_sql;
|
|
m_update.generated_sql += QStringLiteral("\n");
|
|
m_update.generated_sql += QStringLiteral("INSERT INTO db_version (description, version) VALUES ('%1', '%2');\n\n").arg(m_update.info, m_update.version);
|
|
m_update.generated_sql += QStringLiteral("\n--COMMIT;\n\n");
|
|
}
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Generated sql size: " << m_update.generated_sql.size();
|
|
|
|
if (m_update.generated_sql.size() > 0)
|
|
{
|
|
QString sqlFile = DBUpdate::m_defaultPath + m_update.version;
|
|
if (m_update.project.size() > 0)
|
|
sqlFile += QStringLiteral("_") + m_update.project;
|
|
sqlFile += QStringLiteral("_run.sql");
|
|
|
|
QFile file(sqlFile);
|
|
if (file.open(QIODevice::WriteOnly | QFile::Truncate))
|
|
{
|
|
file.write(m_update.generated_sql.toUtf8());
|
|
file.write("\n");
|
|
|
|
file.close();
|
|
INFO_LOG(m_logger) << "Saved GENERATED UPDATE FILE: " << sqlFile;
|
|
m_update.generated_file = sqlFile;
|
|
}
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Error opening file '" << file.fileName() << "' for writing: "
|
|
<< file.errorString();
|
|
m_update.generated_file = QString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace DBUpdate
|