Initial commit

Lts/Tools/DBAdministration/copy_exercise.cpp

@@ -0,0 +1,633 @@
+/*
+ * @RDE_HEADER@
+ * Copy exercise from server to evaluation server
+ * $Id: copy_exercise.cpp 64999 2025-07-01 04:02:56Z fritsche_h $
+ * $HeadURL: svn://192.168.133.21/TDS/branches/product/release_candidates/guez/3dws_rc/Lts/Tools/DBAdministration/copy_exercise.cpp $
+ * $Author: fritsche_h $
+ * Created by Christian Ehrlicher, NLSE, 2018-07-31
+ */
+
+#include "copy_exercise.h"
+
+#include <ngldb/dbcommon.h>
+#include <ngldb/dbconnection.h>
+#include <ngldb/nsqlquery.h>
+#include <ngltools/ngltools_filesystem.h>
+
+#include <QProcess>
+#include <QFile>
+#include <QDir>
+#include <QSqlError>
+#include <QVariant>
+
+namespace DBAdministration
+{
+CopyExercise::CopyExercise(NGL::INGLLogger &logger, CopyFor copyFor, QObject *parent)
+  : QObject(parent)
+  , m_proc(nullptr)
+  , m_procPing(nullptr)
+  , m_exerciseId(-1)
+  , m_copyFor(copyFor)
+  , m_timer(new QTimer(this))
+  , m_stopPing(false)
+  , m_firstPing(false)
+  , m_progressBarValue(0)
+  , m_logger(logger)
+{
+
+  QStringList args({QStringLiteral("-W 10"), // QStringLiteral("10"),
+                    QStringLiteral("-c 6"), //QStringLiteral("6"),
+                    QStringLiteral("EXCDBS01")});
+
+  handleProcPing(args);
+}
+
+CopyExercise::~CopyExercise()
+{
+}
+
+bool CopyExercise::init(int exerciseId,
+                        const QString &srcDbHost, const QString &srcDbName,
+                        const QString &dstDbHost, const QString &dstDbName)
+{
+
+  if (m_exerciseId > 0 )
+    return true;
+
+  m_exerciseId = exerciseId;
+  m_srcDbName = srcDbName;
+  m_srcDbHost = srcDbHost;
+  m_dstDbHost = dstDbHost;
+  m_dstDbName = dstDbName;
+
+  // Server Databases
+  m_dbSrv = DBConnection::open(m_logger,
+                               QStringLiteral("ctc_sv"),
+                               QStringLiteral("ctc11de"),
+                               QStringLiteral("QPSQL"),
+                               m_srcDbHost,
+                               m_srcDbName,
+                               QString(), // <-- default
+                               m_srcDbHost + QLatin1Char('_') + m_srcDbName + QLatin1Char('_') + QString::number(m_exerciseId));
+
+  if (m_copyFor == CopyForEvaluation)
+  {
+    m_dbEvaluation = DBConnection::open(m_logger,
+                                      QStringLiteral("ctc_sv"),
+                                      QStringLiteral("ctc11de"),
+                                      QStringLiteral("QPSQL"),
+                                      m_dstDbHost,
+                                      m_dstDbName,
+                                      QString(),
+                                      m_dstDbHost + QLatin1Char('_') + m_dstDbName + QLatin1Char('_') + QString::number(m_exerciseId));
+
+    if (!m_dbEvaluation.isOpen())
+    {
+      WARNING_LOG(m_logger) << "Could not open DB connection to " << m_dstDbHost
+                            << ", error: " << m_dbEvaluation.lastError().databaseText()
+                            << ", " << m_dbEvaluation.lastError().driverText();
+      return false;
+    }
+
+  }
+  else if (m_copyFor == CopyForAAR)
+  {
+    // Only open exercise for creating exercise user
+    m_dbEvaluation = DBConnection::open(m_logger,
+                                        QStringLiteral("postgres"),
+                                        QStringLiteral("postgres"),
+                                        QStringLiteral("QPSQL"),
+                                        m_dstDbHost,
+                                        QStringLiteral("postgres"),
+                                        QString(),
+                                        m_dstDbHost + QLatin1Char('_') + QStringLiteral("postgres") + QLatin1Char('_') + QString::number(m_exerciseId));
+
+    if (!m_dbEvaluation.isOpen())
+    {
+      WARNING_LOG(m_logger) << "Could not open DB connection to " << m_dstDbHost
+                            << ", error: " << m_dbEvaluation.lastError().databaseText()
+                            << ", " << m_dbEvaluation.lastError().driverText();
+    }
+    else
+    {
+      NSqlQuery q(m_dbEvaluation);
+      //QString user = QStringLiteral("ets_ex_") + QString::number(m_exerciseId);
+      QString user = QStringLiteral("ets_ex_00");
+      QString stmt = QStringLiteral("SELECT create_user_if_not_exists('") + user + QStringLiteral("')");
+      if (!q.exec(stmt))
+        ERROR_LOG(m_logger) << "Error while executing stmt: " << stmt << " error: " << m_dbEvaluation.lastError().databaseText();
+      else
+        INFO_LOG(m_logger) << "Created User " << user;
+      m_dbEvaluation.close();
+    }
+  }
+
+
+  if (!m_dbSrv.isOpen())
+  {
+    WARNING_LOG(m_logger) << "Could not open DB connection to " << m_srcDbHost
+                          << ", error: " << m_dbSrv.lastError().databaseText()
+                          << ", " << m_dbSrv.lastError().driverText();
+    return false;
+
+  }
+
+  DEBUG_LOG(m_logger) << "Successfully initialized database connections";
+  return true;
+}
+
+void CopyExercise::setDownloadScriptIds(const QVector<int> &downloadScriptIds)
+{
+  m_downloadScriptIds = downloadScriptIds;
+}
+
+bool CopyExercise::doCopy(int exerciseId)
+{
+  m_firstPing = true;
+  onPingStart();
+
+  if (exerciseId > 0)
+    m_exerciseId = exerciseId;
+
+  return true;
+}
+
+void CopyExercise::dropDb()
+{
+  const QString dbName = QStringLiteral("lts_db_") + QString::number(m_exerciseId);
+
+  INFO_LOG(m_logger) << "Database to be dropped : " << dbName;
+
+  const QStringList args({QStringLiteral("-U"),
+                          QStringLiteral("postgres"),
+                          QStringLiteral("-h"),
+                          QStringLiteral("localhost"),
+                          dbName});
+
+  handleProcInit(QStringLiteral("dropdb"), args);
+  connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+          this, &CopyExercise::onDropDbFinished2);
+
+  m_proc->start();
+}
+
+bool CopyExercise::runPgDump()
+{
+  const QString schema = DBCommon::getExerciseSchemaName(m_exerciseId);
+
+  QString stmt = QStringLiteral("select sum(pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(tablename)))::bigint from pg_tables where schemaname IN ('") + schema +
+      QStringLiteral("','exm','asm', 'avm', 'bdv', 'core', 'flm', 'aes', 'ism', 'mdm', 'msg', 'opm', 'ppm', 'srm', 'gna', 'tab', 'whg')");
+
+
+  DEBUG_LOG(m_logger) << "stmt: " << stmt;
+  NSqlQuery q(m_dbSrv);
+  if (!q.execAndFetch(stmt))
+  {
+    ERROR_LOG(m_logger) << "Error while estimating size of database dump errror: " << m_dbSrv.lastError().databaseText();
+    m_stopPing = true;
+    return false;
+  }
+
+
+  m_sizePgDump = q.value(0).toLongLong();
+
+  double seconds = m_sizePgDump / 1024 / 100 * 0.0015;
+
+  INFO_LOG(m_logger) << "Size database dump: " << m_sizePgDump;
+  INFO_LOG(m_logger) << " seconds: " << seconds;
+
+  m_timer->setInterval(seconds * 1000);
+  connect(m_timer, &QTimer::timeout, this, &CopyExercise::onTimeoutTimer);
+
+
+  // start process
+  const QStringList args({
+          QStringLiteral("-n"), schema,
+          QStringLiteral("-n"), QStringLiteral("public"),
+          QStringLiteral("-n"), QStringLiteral("exm"),
+          QStringLiteral("-n"), QStringLiteral("asm"),
+          QStringLiteral("-n"), QStringLiteral("avm"),
+          QStringLiteral("-n"), QStringLiteral("bdv"),
+          QStringLiteral("-n"), QStringLiteral("core"),
+          QStringLiteral("-n"), QStringLiteral("flm"),
+          QStringLiteral("-n"), QStringLiteral("aes"),
+          QStringLiteral("-n"), QStringLiteral("ism"),
+          QStringLiteral("-n"), QStringLiteral("mdm"),
+          QStringLiteral("-n"), QStringLiteral("msg"),
+          QStringLiteral("-n"), QStringLiteral("opm"),
+          QStringLiteral("-n"), QStringLiteral("pdm"),
+          QStringLiteral("-n"), QStringLiteral("ppm"),
+          QStringLiteral("-n"), QStringLiteral("srm"),
+          QStringLiteral("-n"), QStringLiteral("gna"),
+          QStringLiteral("-n"), QStringLiteral("tab"),
+          QStringLiteral("-n"), QStringLiteral("whg"),
+
+          QStringLiteral("-U"), QStringLiteral("postgres"),
+          QStringLiteral("-Fc"),
+          QStringLiteral("-f"), getDumpFile(),
+          QStringLiteral("-h"), m_srcDbHost,
+          m_srcDbName
+        });
+
+  handleProcInit(QStringLiteral("pg_dump"), args);
+  connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+          this, &CopyExercise::onPgDumpFinished); 
+
+  m_proc->start();
+  m_progressBarValue = 1;
+  m_timer->start();
+
+  return true;
+}
+
+void CopyExercise::onTimeoutTimer()
+{
+  INFO_LOG(m_logger) << "in onTimeoutTimer()";
+
+  m_progressBarValue += 1;
+  INFO_LOG(m_logger) << "emit : " << m_progressBarValue;
+  emit nextProgress(m_progressBarValue);
+}
+
+void CopyExercise::onPgDumpFinished(int exitCode, QProcess::ExitStatus exitStatus)
+{  
+  m_timer->stop();
+
+  // 1/4 done
+  m_progressBarValue = 25;
+  emit nextProgress(m_progressBarValue);
+
+  if (!checkExitStatus(QStringLiteral("onPgDumpFinished"), exitCode, exitStatus))
+  {
+    QFile::remove(getDumpFile());
+    dropDb();
+    return;
+  }
+
+  const QString dbName = QStringLiteral("lts_db_") + QString::number(m_exerciseId);
+
+  const QStringList args({QStringLiteral("-U"),
+                          QStringLiteral("postgres"),
+                          QStringLiteral("-h"),
+                          m_dstDbHost,
+                          dbName});
+
+  handleProcInit(QStringLiteral("dropdb"), args);
+  connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+          this, &CopyExercise::onDropDbFinished);
+
+  m_proc->start();
+}
+
+void CopyExercise::onDropDbFinished(int exitCode, QProcess::ExitStatus exitStatus)
+{
+  INFO_LOG(m_logger) << "onDropDbFinished: exitCode: " << exitCode << ", exitStatus: " << exitStatus;
+  m_progressBarValue = 30;
+  emit nextProgress(m_progressBarValue);
+
+  const QString dbName = QStringLiteral("lts_db_") + QString::number(m_exerciseId);
+  const QStringList args({QStringLiteral("-U"),
+                          QStringLiteral("postgres"),
+                          QStringLiteral("-T"),
+                          QStringLiteral("template2"),
+                          QStringLiteral("-h"),
+                          m_dstDbHost,
+                          dbName});
+
+  handleProcInit(QStringLiteral("createdb"), args);
+  connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+          this, &CopyExercise::onCreateDbFinished);
+
+  m_proc->start();
+}
+
+void CopyExercise::onDropDbFinished2(int exitCode, QProcess::ExitStatus exitStatus)
+{
+
+  ERROR_LOG(m_logger) << "onDropDbFinished2: exitCode: " << exitCode << ", exitStatus: " << exitStatus;
+  emit copyDbFailed();
+}
+
+void CopyExercise::onCreateDbFinished(int exitCode, QProcess::ExitStatus exitStatus)
+{
+  INFO_LOG(m_logger) << "onCreateDbFinished: exitCode: " << exitCode << ", exitStatus: " << exitStatus;
+  m_progressBarValue = 35;
+  emit nextProgress(m_progressBarValue);
+
+  if (exitCode > 0)
+  {
+    ERROR_LOG(m_logger) << "Exercise " << m_exerciseId << " already exists";
+    QFile::remove(getDumpFile());
+    emit copyDbFailed();
+    return;
+  }
+
+  const QString dbName = QStringLiteral("lts_db_") + QString::number(m_exerciseId);
+  const QStringList args({QStringLiteral("-U"),
+                          QStringLiteral("postgres"),                                                    
+                          QStringLiteral("-h"),
+                          m_dstDbHost,
+                          QStringLiteral("-d"),
+                          dbName,
+                          QStringLiteral("-j"),
+                          QStringLiteral("4"),
+                          getDumpFile(),
+                          });
+
+  handleProcInit(QStringLiteral("pg_restore"), args);
+  if (m_copyFor == CopyForEvaluation)
+  {
+    connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+            this, &CopyExercise::onPsqlFinishedForEvaluation);
+  }
+  else
+  {
+    connect(m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+            this, &CopyExercise::onPsqlFinishedForAAR);
+  }
+
+  double seconds = m_sizePgDump / 1024 / 100 * 0.001;
+  INFO_LOG(m_logger) << " seconds: " << seconds;
+
+  m_timer->setInterval(seconds * 1000);
+  m_timer->start();
+
+  m_proc->start();
+}
+
+void CopyExercise::onPsqlFinishedForEvaluation(int exitCode, QProcess::ExitStatus exitStatus)
+{
+  m_timer->stop();
+  m_progressBarValue = 75;
+  emit nextProgress(m_progressBarValue);
+
+  if (!checkExitStatus(QStringLiteral("onPsqlFinishedForEvaluation"), exitCode, exitStatus))
+    return;
+
+  if ( exitStatus == QProcess::ExitStatus::NormalExit )
+    QFile::remove(getDumpFile());
+
+  // get exercise data from db
+  QVariant exName, exStartTime, exEndTime;
+  {
+    NSqlQuery q(m_dbSrv);
+
+    QString stmt = QStringLiteral("SELECT name, begin_time, end_time FROM exm.exercise WHERE id = ") + QString::number(m_exerciseId);
+    if (q.execAndFetch(stmt))
+    {
+      int i = 0;
+      exName      = q.value(i++);
+      exStartTime = q.value(i++);
+      exEndTime   = q.value(i++);
+    }
+    else
+    {
+      ERROR_LOG(m_logger) << "Error while reading exercise info for exercise " << m_exerciseId << " from source database"
+                          << ", error: " << q.lastError().databaseText()
+                          << ", " << q.lastError().driverText()
+                          << ", stmt: " << stmt;
+      emit copyDbFailed();
+      m_stopPing = true;
+      return;
+    }
+  }
+
+  NSqlQuery q(m_dbEvaluation);
+
+  QString stmt = QStringLiteral("INSERT INTO local_databases (name, db_name, begin_time, end_time) "
+                                "VALUES (:name, :dbName, :beginTime, :endTime) ");
+
+  q.prepare(stmt);
+  q.bindValue(QStringLiteral(":name"), exName);
+  QString dbName = QStringLiteral("lts_db_") + QString::number(m_exerciseId);
+  q.bindValue(QStringLiteral(":dbName"), dbName);
+  q.bindValue(QStringLiteral(":beginTime"), exStartTime);
+  q.bindValue(QStringLiteral(":endTime"), exEndTime);
+
+  if (!q.exec())
+  {
+    ERROR_LOG(m_logger) << "Error while inserting data in local_databases: exerciseId = " << m_exerciseId
+                        << ", error: " << q.lastError().databaseText()
+                        << ", " << q.lastError().driverText();
+    emit copyDbFailed();
+  }
+  else
+  {
+    emit copyDbFinished();    
+  }
+  m_stopPing = true;
+  m_dbEvaluation.close();
+}
+
+void CopyExercise::onPsqlFinishedForAAR(int exitCode, QProcess::ExitStatus exitStatus)
+{
+  m_timer->stop();
+  m_progressBarValue = 75;
+  emit nextProgress(m_progressBarValue);
+
+  if (!checkExitStatus(QStringLiteral("onPsqlFinishedForAAR"), exitCode, exitStatus))
+    return;
+
+  if ( exitStatus == QProcess::ExitStatus::NormalExit )
+    QFile::remove(getDumpFile());
+
+  //init procedures in schema public
+  const QString fileName = QStringLiteral("/shd/CTC/AAR/bin/test/init_db_procedures.sql");
+  const QStringList args({QStringLiteral("-U"),
+                          QStringLiteral("postgres"),
+                          QStringLiteral("-h"),
+                          m_dstDbHost,
+                          QStringLiteral("-d"),
+                          m_dstDbName,
+                          QStringLiteral("-f"),
+                          fileName
+                          });
+  handleProcInit(QStringLiteral("psql"), args);
+  //init procedures in schema public
+
+  // now open the downloaded database
+  if (!m_dbEvaluation.isOpen())
+  {
+    m_dbEvaluation = DBConnection::open(m_logger,
+                                    QStringLiteral("postgres"),
+                                    QStringLiteral("postgres"),
+                                    QStringLiteral("QPSQL"),
+                                    m_dstDbHost,
+                                    m_dstDbName,
+                                    QString(),
+                                    m_dstDbHost + QLatin1Char('_') + m_dstDbName + QLatin1Char('_') + QString::number(m_exerciseId));
+
+    if (!m_dbEvaluation.isOpen())
+    {
+      ERROR_LOG(m_logger) << "Could not open DB connection to " << m_dstDbHost
+                            << ", error: " << m_dbEvaluation.lastError().databaseText()
+                            << ", " << m_dbEvaluation.lastError().driverText();
+      emit copyDbFailed();
+      m_stopPing = true;
+      return;
+    }
+  }
+
+  NSqlQuery q(m_dbEvaluation);
+
+  const QString schema = DBCommon::getExerciseSchemaName(m_exerciseId);
+  QStringList downloadScriptIds;
+  downloadScriptIds.reserve(m_downloadScriptIds.size());
+  for (int id : qAsConst(m_downloadScriptIds))
+    downloadScriptIds.push_back(QString::number(id));
+
+  QString stmt = QLatin1String("DELETE FROM ") + schema + QLatin1String(".pre_presentation WHERE id not in (") + downloadScriptIds.join(QLatin1Char(',')) + QLatin1Char(')');
+
+  if (!q.exec(stmt))
+  {
+    ERROR_LOG(m_logger) << "Error while deleting scripts from database";
+    emit copyDbFailed();
+  }
+  else
+  {
+//    stmt = QLatin1String("DELETE FROM exm.exercise WHERE id != ") + QString::number(m_exerciseId);
+// deleting foreign key will delete all dependences in cascade, so all FLM data for that exercise
+    stmt = QLatin1String("UPDATE exm.exercise SET exercise_state_id = 6 WHERE id != ") + QString::number(m_exerciseId);
+    DEBUG_LOG(m_logger) << "Executing statement: " << stmt;
+    if (!q.exec(stmt))
+      ERROR_LOG(m_logger) << "Error on updating exm.exercise " << m_dbEvaluation.lastError().databaseText();
+    else
+      DEBUG_LOG(m_logger) << "Statement succesfully executed";
+
+    stmt = QLatin1String("GRANT USAGE ON SCHEMA PUBLIC TO ets_ro;");
+    DEBUG_LOG(m_logger) << "Executing statement: " << stmt;
+    if (!q.exec(stmt))
+      ERROR_LOG(m_logger) << "Error on grant usage " << m_dbEvaluation.lastError().databaseText();
+    else
+      DEBUG_LOG(m_logger) << "Statement succesfully executed";
+
+    stmt = QLatin1String("GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO ets_ro;");
+    DEBUG_LOG(m_logger) << "Executing statement: " << stmt;
+    if (!q.exec(stmt))
+      ERROR_LOG(m_logger) << "Error on grant execute " << m_dbEvaluation.lastError().databaseText();
+    else
+      DEBUG_LOG(m_logger) << "Statement succesfully executed";
+
+    emit copyDbFinished();
+  }
+  m_stopPing = true;
+  m_dbEvaluation.close();
+}
+
+bool CopyExercise::checkExitStatus(const QString &procName, int exitCode, QProcess::ExitStatus exitStatus)
+{
+  if (exitCode > 0)
+  {
+    NOTICE_LOG(m_logger) << procName << ": exitCode: " << exitCode << ", exitStatus: " << exitStatus;
+    WARNING_LOG(m_logger) << m_proc->readAllStandardError() << m_proc->readAllStandardOutput();
+    m_stopPing = true;
+    return false;
+  }
+
+  return true;
+}
+
+void CopyExercise::handleProcPing(const QStringList &args)
+{
+  if (m_procPing)
+  {
+    m_procPing->disconnect(this);
+    m_procPing->deleteLater();
+  }
+  m_procPing = new QProcess(this);
+  QString errStr;
+  const QString exePath = NGL::postgresExecutablePath(QStringLiteral("ping"), errStr);
+  if (!errStr.isEmpty())
+    WARNING_LOG(m_logger) << errStr;
+  INFO_LOG(m_logger) << "Starting process '" << exePath << "' with args '"
+                       << args.join(QLatin1Char(' ')) << "'";
+  m_procPing->setProgram(exePath);
+  m_procPing->setArguments(args);
+  connect(m_procPing, &QProcess::errorOccurred,
+          this, &CopyExercise::onErrorOccured);
+  connect(m_procPing, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &CopyExercise::onPingFinished);
+
+}
+
+void CopyExercise::onPingStart()
+{
+  m_stopPing = false;
+  m_procPing->start();
+  INFO_LOG(m_logger) << "ping started ";
+}
+
+void CopyExercise::onPingFinished(int exitCode, QProcess::ExitStatus exitStatus)
+{
+  if (exitCode > 0)
+    DEBUG_LOG(m_logger) << "got ping result with exitCode != 0. exitCode: " << exitCode << ", exitStatus: " << exitStatus;
+  else
+  {
+    if (m_firstPing)
+    {
+      m_firstPing = false;
+      if (!runPgDump())
+      {
+        ERROR_LOG(m_logger) << "Error running pg_dump for exercise " << m_exerciseId;
+        emit copyDbFailed();
+        m_stopPing = true;
+      }
+    }
+    if (!m_stopPing)
+      QTimer::singleShot(2000, this, &CopyExercise::onPingStart);
+  }
+}
+
+void CopyExercise::stopPing()
+{
+  m_stopPing = true;
+}
+
+void CopyExercise::handleProcInit(const QString &program, const QStringList &args)
+{
+  if (m_proc)
+  {
+    m_proc->disconnect(this);
+    m_proc->deleteLater();
+  }
+  m_proc = new QProcess(this);
+  QString errStr;
+  const QString exePath = NGL::postgresExecutablePath(program, errStr);
+  if (!errStr.isEmpty())
+    WARNING_LOG(m_logger) << errStr;
+  INFO_LOG(m_logger) << "Starting process '" << exePath << "' with args '"
+                       << args.join(QLatin1Char(' ')) << "'";
+  m_proc->setProgram(exePath);
+  m_proc->setArguments(args);
+  connect(m_proc, &QProcess::errorOccurred,
+          this, &CopyExercise::onErrorOccured);
+}
+
+void CopyExercise::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 CopyExercise::onErrorOccured(QProcess::ProcessError error)
+{
+  ERROR_LOG(m_logger) << "onErrorOccured: error: " << error << ", " << m_proc->readAllStandardOutput() << ", " << m_proc->readAllStandardError();
+  m_timer->stop();
+}
+
+QString CopyExercise::getDumpFile() const
+{  
+  return QDir::tempPath() + QLatin1Char('/') + m_srcDbName + QLatin1Char('_')+ QString::number(m_exerciseId) + QStringLiteral(".dump");
+}
+
+} // namespace DBAdministration