// Doxygen skip:
/// @cond
void QueueManager::handleSubmittedStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_submittedTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_submittedTracker);
if (s->getStatus() != Structure::Submitted) {
return;
}
switch (m_opt->queueInterface(s->getCurrentOptStep())->getStatus(s)) {
case QueueInterface::Running:
case QueueInterface::Queued:
case QueueInterface::Success:
case QueueInterface::Started:
// Update the structure as "InProcess"
s->lock().lockForWrite();
s->setStatus(Structure::InProcess);
s->lock().unlock();
emit structureUpdated(s);
break;
case QueueInterface::Error:
s->lock().lockForWrite();
s->setStatus(Structure::Restart);
s->lock().unlock();
emit structureUpdated(s);
break;
case QueueInterface::CommunicationError:
case QueueInterface::Unknown:
case QueueInterface::Pending:
default:
// nothing to do but wait
break;
}
}
void DbStructureModel::reloadData()
{
beginResetModel();
// Remove all data except for the root item
while(rootItem->childCount())
delete rootItem->child(0);
// Return here if no DB is opened
if(!m_db.isOpen())
{
endResetModel();
emit structureUpdated();
return;
}
// Create the nodes for browsables and for tables, indices, views and triggers. The idea here is to basically have two trees in one model:
// In the root node there are two nodes: 'browsables' and 'all'. The first node contains a list of all browsable objects, i.e. views and tables.
// The second node contains four sub-nodes (tables, indices, views and triggers), each containing a list of objects of that type.
// This way we only have to have and only have to update one model and can use it in all sorts of places, just by setting a different root node.
browsablesRootItem = new QTreeWidgetItem(rootItem);
browsablesRootItem->setIcon(ColumnName, QIcon(QString(":/icons/view")));
browsablesRootItem->setText(ColumnName, tr("Browsables"));
// Make sure to always load the main schema first
QTreeWidgetItem* itemAll = new QTreeWidgetItem(rootItem);
itemAll->setIcon(ColumnName, QIcon(QString(":/icons/database")));
itemAll->setText(ColumnName, tr("All"));
itemAll->setText(ColumnObjectType, "database");
buildTree(itemAll, "main");
// Add the temporary database as a node if it isn't empty. Make sure it's always second if it exists.
if(!m_db.schemata["temp"].isEmpty())
{
QTreeWidgetItem* itemTemp = new QTreeWidgetItem(itemAll);
itemTemp->setIcon(ColumnName, QIcon(QString(":/icons/database")));
itemTemp->setText(ColumnName, tr("Temporary"));
itemTemp->setText(ColumnObjectType, "database");
buildTree(itemTemp, "temp");
}
// Now load all the other schemata last
for(auto it=m_db.schemata.constBegin();it!=m_db.schemata.constEnd();++it)
{
// Don't load the main and temp schema again
if(it.key() != "main" && it.key() != "temp")
{
QTreeWidgetItem* itemSchema = new QTreeWidgetItem(itemAll);
itemSchema->setIcon(ColumnName, QIcon(QString(":/icons/database")));
itemSchema->setText(ColumnName, it.key());
itemSchema->setText(ColumnObjectType, "database");
buildTree(itemSchema, it.key());
}
}
// Refresh the view
endResetModel();
emit structureUpdated();
}
// Doxygen skip:
/// @cond
void QueueManager::addStructureToSubmissionQueue_(Structure* s, int optStep)
{
Q_ASSERT(trackerContainsStructure(s, &m_newSubmissionTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_newSubmissionTracker);
// Update structure
s->lock().lockForWrite();
if (s->getStatus() != Structure::Optimized) {
s->setStatus(Structure::WaitingForOptimization);
if (optStep != -1) {
s->setCurrentOptStep(optStep);
}
}
s->lock().unlock();
// Perform writing
m_opt->queueInterface(s->getCurrentOptStep())->writeInputFiles(s);
m_jobStartTracker.lockForWrite();
m_jobStartTracker.append(s);
m_jobStartTracker.unlock();
m_runningTracker.lockForWrite();
m_runningTracker.append(s);
m_runningTracker.unlock();
emit structureUpdated(s);
}
// Doxygen skip:
/// @cond
void QueueManager::handleInProcessStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_inProcessTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_inProcessTracker);
// Revalidate assumptions
if (s->getStatus() != Structure::InProcess) {
return;
}
QueueInterface* qi = m_opt->queueInterface(s->getCurrentOptStep());
switch (qi->getStatus(s)) {
case QueueInterface::Running:
case QueueInterface::Queued:
case QueueInterface::CommunicationError:
case QueueInterface::Unknown:
case QueueInterface::Pending:
case QueueInterface::Started:
{
// Kill the structure if it has exceeded the allowable time.
// Only perform this for remote queues.
if (m_opt->cancelJobAfterTime() &&
s->getOptElapsedHours() > m_opt->hoursForCancelJobAfterTime() &&
qi->getIDString().toLower() != "local") {
killStructure(s);
emit structureUpdated(s);
return;
}
// Nothing to do but wait
break;
}
case QueueInterface::Success:
updateStructure(s);
break;
case QueueInterface::Error:
s->lock().lockForWrite();
s->setStatus(Structure::Error);
s->lock().unlock();
emit structureUpdated(s);
break;
}
return;
}
void QueueManager::updateStructure(Structure* s)
{
s->lock().lockForWrite();
s->stopOptTimer();
s->resetFailCount();
s->setStatus(Structure::Updating);
s->lock().unlock();
if (!m_opt->optimizer(s->getCurrentOptStep())->update(s)) {
s->lock().lockForWrite();
s->setStatus(Structure::Error);
s->lock().unlock();
emit structureUpdated(s);
return;
}
s->lock().lockForWrite();
s->setStatus(Structure::StepOptimized);
s->lock().unlock();
emit structureUpdated(s);
return;
}
// Doxygen skip:
/// @cond
void QueueManager::handleErrorStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_errorTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_errorTracker);
if (s->getStatus() != Structure::Error) {
return;
}
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "failed";
}
stopJob(s);
// Lock for writing
QWriteLocker locker(&s->lock());
s->addFailure();
// If the number of failures has exceed the limit, take
// appropriate action
if (s->getFailCount() >= m_opt->failLimit) {
switch (OptBase::FailActions(m_opt->failAction)) {
case OptBase::FA_DoNothing:
default:
// resubmit job
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
case OptBase::FA_KillIt:
locker.unlock();
killStructure(s);
emit structureUpdated(s);
return;
case OptBase::FA_Randomize:
s->setStatus(Structure::Empty);
locker.unlock();
m_opt->replaceWithRandom(s, tr("excessive failures"));
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
case OptBase::FA_NewOffspring:
s->setStatus(Structure::Empty);
locker.unlock();
m_opt->replaceWithOffspring(s, tr("excessive failures"));
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
}
}
// Resubmit job if failure limit hasn't been reached
else {
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
}
}
// Doxygen skip:
/// @cond
void QueueManager::handleStepOptimizedStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_stepOptimizedTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_stepOptimizedTracker);
QWriteLocker locker(&s->lock());
// Validate assumptions
if (s->getStatus() != Structure::StepOptimized) {
return;
}
s->stopOptTimer();
QString err;
if (!m_opt->checkStepOptimizedStructure(s, &err)) {
// Structure failed a post optimization step:
m_opt->warning(QString("Structure %1 failed a post-optimization step: %2")
.arg(s->getIDString())
.arg(err));
s->setStatus(Structure::Killed);
locker.unlock();
emit structureUpdated(s);
return;
}
// update optstep and relaunch if necessary
if (s->getCurrentOptStep() + 1 <
static_cast<unsigned int>(m_opt->getNumOptSteps())) {
// Print an update to the terminal if we are not using the GUI
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "completed step" << s->getCurrentOptStep();
}
s->setCurrentOptStep(s->getCurrentOptStep() + 1);
// Update status
s->setStatus(Structure::WaitingForOptimization);
m_runningTracker.lockForWrite();
m_runningTracker.append(s);
m_runningTracker.unlock();
locker.unlock();
emit structureUpdated(s);
addStructureToSubmissionQueue(s);
return;
}
// Otherwise, it's done
else {
// Print an update to the terminal if we are not using the GUI
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "is optimized!";
}
s->setStatus(Structure::Optimized);
locker.unlock();
handleOptimizedStructure(s);
}
}