ScenarioListController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore::core
 * @author     Cedric Seehausen (usdnr at kit dot edu)
 * @date       2016
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#include "ScenarioListController.h"
 
#include <sstream>
 
#include <QApplication>
#include <QMessageBox>
#include <QSettings>
#include <QTimer>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/util/ScenarioManagerCommon/executor/StarterFactory.h>
#include <ArmarXCore/util/ScenarioManagerCommon/executor/StopStrategyFactory.h>
#include <ArmarXCore/util/ScenarioManagerCommon/executor/StopperFactory.h>
#include <ArmarXCore/util/ScenarioManagerCommon/parser/DependenciesGenerator.h>
#include <ArmarXCore/util/ScenarioManagerCommon/parser/PackageBuilder.h>
#include <ArmarXCore/util/ScenarioManagerCommon/parser/StatusManager.h>
#include <ArmarXCore/util/ScenarioManagerCommon/parser/XMLScenarioParser.h>
#include <ArmarXCore/util/ScenarioManagerCommon/parser/iceparser.h>
 
#include "../gui/namelocationview.h"
#include "../gui/scenarioitem.h"
 
using namespace ScenarioManager;
using namespace Controller;
using namespace Data_Structure;
using namespace Parser;
using namespace Exec;
 
#define UPDATE_TIMER 500 //ms
 
ScenarioListController::ScenarioListController(PackageVectorPtr packages,
                                               ExecutorPtr executor,
                                               QObject* parent) :
    QObject(parent),
    treemodel(),
    model(new FilterableTreeModelSortFilterProxyModel()),
    packages(packages),
    executor(executor)
{
    qRegisterMetaType<ApplicationInstanceStatusMap>("ApplicationInstanceStatusMap");
    qRegisterMetaType<FilterableTreeModelSortFilterProxyModelPtr>(
        "FilterableTreeModelSortFilterProxyModelPtr");
 
    QTimer* timer = new QTimer(this);
    QObject::connect(timer, SIGNAL(timeout()), this, SLOT(updateStati()));
    timer->start(UPDATE_TIMER);
 
    updateTask = new armarx::SimplePeriodicTask<>(
        [&] { fetchStati(); }, 100, false, "ScenarioManagerUpdateStatusTask");
    updateTask->start();
 
    model->setDynamicSortFilter(true);
    model->setSourceModel(&treemodel);
 
    QObject::connect(&createScenarioView,
                     SIGNAL(created(std::string, std::string)),
                     this,
                     SLOT(createdScenario(std::string, std::string)));
 
    QObject::connect(&treemodel,
                     SIGNAL(applicationsDrop(
                         QList<QPair<QString, ScenarioManager::Data_Structure::Application*>>,
                         int,
                         QModelIndex)),
                     this,
                     SLOT(addApplicationsToScenario(
                         QList<QPair<QString, ScenarioManager::Data_Structure::Application*>>,
                         int,
                         QModelIndex)));
    QObject::connect(this,
                     SIGNAL(statusFetched(ApplicationInstanceStatusMap)),
                     this,
                     SLOT(updateStati(ApplicationInstanceStatusMap)));
}
 
ScenarioListController::~ScenarioListController()
{
    updateTask->stop();
}
 
FilterableTreeModelSortFilterProxyModelPtr
ScenarioListController::getTreeModel()
{
    return model;
}
 
void
ScenarioListController::stop(int row, int column, QModelIndex parent)
{
    ScenarioItem* item =
        model->data(model->index(row, column, parent), SCENARIOITEMSOURCE).value<ScenarioItem*>();
    if (item == nullptr)
    {
        return;
    }
    if (parent.isValid())
    {
        if (parent.parent().isValid()) //stop application
        {
            if (!item->isEnabled())
            {
                return;
            }
            ApplicationInstancePtr instance = item->getApplicationInstance();
            executor->stopApplication(instance);
        }
        else //stop packageSubpackage
        {
            if (!item->isEnabled())
            {
                return;
            }
            for (const auto& app : *item->getApplicationInstances())
            {
                executor->stopApplication(app);
            }
        }
    }
    else //stop scenario
    {
        ScenarioPtr scenario = item->getScenario();
        executor->stopScenario(scenario);
    }
}
 
void
ScenarioListController::stopUpdateTask()
{
    updateTask->stop();
}
 
void
ScenarioListController::start(int row, int column, QModelIndex parent)
{
    ScenarioItem* item =
        model->data(model->index(row, column, parent), SCENARIOITEMSOURCE).value<ScenarioItem*>();
    if (!item)
    {
        return;
    }
    if (parent.isValid())
    {
        if (parent.parent().isValid()) //start application
        {
            if (!item->isEnabled())
            {
                return;
            }
            ApplicationInstancePtr instance = item->getApplicationInstance();
            instance->updateFound();
            if (!instance->getFound())
            {
                ShowWarningDialog(
                    "The binary `" + QString::fromStdString(instance->getExecutableAbsPath()) +
                    "` for the application " + QString::fromStdString(instance->getName()) +
                    " could not be found");
                treemodel.update();
                return;
            }
            auto scenario = instance->getScenario();
            executor->startApplication(instance);
        }
        else // start packagesubtree
        {
            if (!item->isEnabled())
            {
                return;
            }
            ARMARX_CHECK_EXPRESSION(item->getApplicationInstances());
            for (const auto& app : *item->getApplicationInstances())
            {
                app->updateFound();
                if (!app->getFound())
                {
                    ShowWarningDialog("The Binary for the Application " +
                                      QString::fromStdString(app->getName()) +
                                      " could not be found");
                    treemodel.update();
                    return;
                }
 
                executor->startApplication(app);
            }
        }
    }
    else //start scenario
    {
        startScenario(item);
    }
}
 
void
ScenarioListController::startScenario(ScenarioItem* scenarioItem)
{
    ScenarioPtr scenario = scenarioItem->getScenario();
    StartScenario(scenario, executor, iceAdmin);
}
 
void
ScenarioListController::restart(int row, int column, QModelIndex parent)
{
    //hole entsprechende application aus dem package und uebergebe sie dem executor zum restarten & update model entsprechend
    ScenarioItem* item =
        model->data(model->index(row, column, parent), SCENARIOITEMSOURCE).value<ScenarioItem*>();
    if (item == nullptr || !item->isEnabled())
    {
        return;
    }
    if (parent.isValid())
    {
        if (parent.parent().isValid())
        {
            //start/stop application
            executor->restartApplication(item->getApplicationInstance());
        }
        else
        {
            //start/stop packageSubtree
            for (const auto& app : *item->getApplicationInstances())
            {
                executor->restartApplication(app);
            }
        }
    }
    else //start/stop scenario
    {
        try
        {
            executor->restartScenario(item->getScenario());
        }
        catch (IceGrid::ServerStartException& ex)
        {
            ShowWarningDialog("Ice had an launching error. Please make sure your remote launch "
                              "settings are correct");
        }
    }
}
 
void
ScenarioListController::addApplicationsToScenario(
    QList<QPair<QString, ScenarioManager::Data_Structure::Application*>> applications,
    int row,
    const QModelIndex& parent)
{
    ScenarioItem* item; //reinterpret_cast<ScenarioItem*>(model->data(parent, SCENARIOITEM).data());
    QModelIndex scenarioIndex;
 
    if (parent.parent().isValid() && parent.parent().parent().isValid())
    {
        item = model->data(parent.parent().parent(), SCENARIOITEMPROXY).value<ScenarioItem*>();
        scenarioIndex = parent.parent().parent();
    }
    else if (parent.parent().isValid())
    {
        item = model->data(parent.parent(), SCENARIOITEMPROXY).value<ScenarioItem*>();
        scenarioIndex = parent.parent();
    }
    else
    {
        item = model->data(parent, SCENARIOITEMPROXY).value<ScenarioItem*>();
        scenarioIndex = parent;
    }
 
    if (item == nullptr)
    {
        return;
    }
 
    ScenarioPtr scenario = item->getScenario();
    if (!scenario->isScenarioFileWriteable())
    {
        QMessageBox::critical(
            0,
            "Adding application failed!",
            "The scenario '" + QString::fromStdString(scenario->getName()) +
                "' is read only. You cannot add an application to this scenario!");
        return;
    }
    Parser::DependenciesGenerator generator;
    std::vector<std::string> acceptedApps =
        generator.getDependencieTree(scenario->getPackage()->getName());
 
 
    for (const auto& pair : applications)
    {
        ScenarioManager::Data_Structure::Application* app = pair.second;
        PackagePtr appPackage;
        for (const auto& package : *packages)
        {
            for (const auto& pApp : *package->getApplications())
            {
                if (pApp->getName().compare(app->getName()) == 0)
                {
                    appPackage = package;
                }
            }
        }
 
        if (appPackage.get() == nullptr)
        {
            return;
        }
 
        if (std::find(acceptedApps.begin(), acceptedApps.end(), appPackage->getName()) ==
            acceptedApps.end())
        {
            const std::string dependenciesStr = simox::alg::join(acceptedApps, ", ");
 
            QMessageBox box;
            QString message("You cannot drop an app from ");
            message.append(QString::fromStdString(appPackage->getName()));
            message.append(" into a scenario from ");
            message.append(QString::fromStdString(scenario->getPackage()->getName()));
            message.append(QString::fromStdString(". Package `" +
                                                  scenario->getPackage()->getName() +
                                                  "` depends on " + dependenciesStr));
            box.setText(message);
            box.exec();
            return;
        }
 
 
        const std::string appName = app->getName();
 
        int instanceCounter = 0;
        std::string instanceName = pair.first.toStdString();
        if (instanceName.empty())
        {
            for (const ApplicationInstancePtr& instances : *scenario->getApplications())
            {
                if (instances->getName().compare(appName) == 0)
                {
                    instanceCounter++;
                }
            }
            if (instanceCounter == 0)
            {
                instanceName = "";
            }
            else
            {
                instanceName = "instance" + std::to_string(instanceCounter);
            }
        }
        else
        {
            for (const ApplicationInstancePtr& instances : *scenario->getApplications())
            {
                if (instances->getInstanceName().compare(instanceName) == 0)
                {
                    instanceCounter++;
                }
            }
            if (instanceCounter > 0)
            {
                instanceName += std::to_string(instanceCounter);
            }
        }
 
 
        std::string configPath = scenario->getPath();
        configPath = configPath.substr(0, configPath.find_last_of('/'));
        configPath.append("/config/");
 
 
        configPath.append(app->getName());
        if (!instanceName.empty())
        {
            configPath.append(".");
            configPath.append(instanceName);
        }
        configPath.append(".cfg");
 
        std::ofstream out(configPath);
        out.close();
 
        ApplicationInstancePtr appInstance(new ApplicationInstance(app->getExecutableName(),
                                                                   app->getPathToExecutable(),
                                                                   instanceName,
                                                                   configPath,
                                                                   appPackage->getName(),
                                                                   scenario,
                                                                   "",
                                                                   true));
 
        std::string cacheDir = Parser::IceParser::getCacheDir();
 
        executor->loadAndSetCachedProperties(appInstance, cacheDir, true);
        appInstance->load(true);
 
        for (const auto& elem : app->getProperties()->getProperties()->getPropertiesForPrefix(""))
        {
            appInstance->modifyProperty(elem.first, elem.second);
            appInstance->setDefaultPropertyEnabled(elem.first, true);
        }
 
        appInstance->save();
 
        scenario->addApplication(appInstance);
 
        QModelIndex subScenarioIndex =
            findSubScenarioModelIndexByScenarioIndex(scenarioIndex, appPackage->getName());
        ;
 
        //if this is unvalid than the user dropped an app out of an package that is not currently used inside the scenario
        //so create subscenario item
        //this behaviour was kind of buggy be careful while optimising
        if (!subScenarioIndex.isValid())
        {
            std::vector<ApplicationInstancePtr> list;
 
            ScenarioItem* subScenarioItem = new ScenarioItem(appPackage->getName(), list);
 
            treemodel.insertRow(0, subScenarioItem, scenarioIndex);
 
            subScenarioIndex =
                findSubScenarioModelIndexByScenarioIndex(scenarioIndex, appPackage->getName());
 
            treemodel.insertRow(0, new ScenarioItem(appInstance), subScenarioIndex);
        }
        else
        {
            treemodel.insertRow(0, new ScenarioItem(appInstance), subScenarioIndex);
        }
    }
    scenario->save();
}
 
void
ScenarioListController::removeItem(QModelIndex item)
{
    ScenarioItem* scenItem;
    if (item.parent().isValid() && item.parent().parent().isValid())
    {
        scenItem = model->data(item.parent().parent(), SCENARIOITEMSOURCE).value<ScenarioItem*>();
 
        if (scenItem == nullptr)
        {
            return;
        }
 
        ScenarioItem* appItem = model->data(item, SCENARIOITEMSOURCE).value<ScenarioItem*>();
 
        ScenarioPtr scenario = scenItem->getScenario();
        scenario->removeApplication(appItem->getApplicationInstance());
 
        scenario->save();
        treemodel.removeRow(model->mapToSource(item).row(), model->mapToSource(item.parent()));
    }
    else if (item.parent().isValid())
    {
        scenItem = model->data(item.parent(), SCENARIOITEMSOURCE).value<ScenarioItem*>();
 
        if (scenItem == nullptr)
        {
            return;
        }
 
        ScenarioItem* packageItem = model->data(item, SCENARIOITEMSOURCE).value<ScenarioItem*>();
 
        ScenarioPtr scenario = scenItem->getScenario();
 
        for (const auto& app : *packageItem->getApplicationInstances())
        {
            scenario->removeApplication(app);
        }
        scenario->save();
        treemodel.removeRow(model->mapToSource(item).row(), model->mapToSource(item.parent()));
    }
    else
    {
        scenItem = model->data(item, SCENARIOITEMSOURCE).value<ScenarioItem*>();
 
        if (scenItem == nullptr)
        {
            return;
        }
 
        ScenarioPtr scen = scenItem->getScenario();
 
        const std::string file =
            armarx::ArmarXDataPath::GetDefaultUserConfigPath() + "/ScenarioManager.conf";
        QSettings settings(QString(file.c_str()), QSettings::NativeFormat);
        QStringList scenarios = settings.value("scenarios").toStringList();
        scenarios.removeDuplicates();
        QString toFind(QString::fromStdString(scen->getName()));
        toFind.append("::Package::");
        toFind.append(QString::fromStdString(scen->getPackage()->getName()));
        scenarios.removeAt(scenarios.indexOf(toFind));
        settings.setValue("scenarios", scenarios);
 
        for (const auto& package : *packages)
        {
            for (auto it = package->getScenarios()->begin(); it != package->getScenarios()->end();
                 ++it)
            {
                if (scen.get() == it->get())
                {
                    package->getScenarios()->erase(it);
                    break;
                }
            }
        }
        treemodel.removeRow(model->mapToSource(item).row(), model->mapToSource(item.parent()));
        emit updated();
    }
}
 
void
ScenarioListController::createScenario()
{
    ARMARX_TRACE;
 
    if (packages->size() != 0)
    {
        QVector<QPair<QString, bool>> packageNames;
        for (const auto& package : *packages)
        {
            packageNames << qMakePair(QString::fromStdString(package->getName()),
                                      package->isScenarioPathWritable());
        }
        createScenarioView.setPackages(packageNames);
        createScenarioView.exec();
    }
    else
    {
        QMessageBox messageBox;
        messageBox.setText("You have to have at least one Package open to create an Scenario");
        messageBox.exec();
    }
 
    ARMARX_TRACE;
}
 
void
ScenarioListController::createdScenario(std::string name, std::string packageStr)
{
    XMLScenarioParser parser;
 
    PackagePtr package;
    for (unsigned int i = 0; i < packages->size(); i++)
    {
        if (packages->at(i)->getName().compare(packageStr) == 0)
        {
            package = packages->at(i);
            break;
        }
    }
    if (package.get() == nullptr)
    {
        return;
    }
 
    if (parser.isScenarioexistent(name, package))
    {
        QMessageBox box;
        QString message("The Scenario " + QString::fromStdString(name) +
                        " already exists in Package " + QString::fromStdString(packageStr));
        box.setText(message);
        box.exec();
        return;
    }
 
    ScenarioPtr ptr = parser.createNewScenario(name, package);
    if (ptr.get() == nullptr)
    {
        return;
    }
 
    for (const auto& p : *packages)
    {
        if (p->getName().compare(packageStr) == 0)
        {
            p->addScenario(ptr);
            treemodel.insertRow(0, new ScenarioItem(ptr));
            break;
        }
    }
 
    const std::string file =
        armarx::ArmarXDataPath::GetDefaultUserConfigPath() + "/ScenarioManager.conf";
    QSettings settings(QString(file.c_str()), QSettings::NativeFormat);
    QStringList scenarios = settings.value("scenarios").toStringList();
    scenarios.removeDuplicates();
    QString toAdd;
    toAdd.append(QString::fromStdString(ptr->getName()));
    toAdd.append("::Package::");
    toAdd.append(QString::fromStdString(package->getName()));
    scenarios.append(toAdd);
    settings.setValue("scenarios", scenarios);
    emit updated();
}
 
void
ScenarioListController::showApplication(const QModelIndex& index)
{
 
    ScenarioItem* item = model->data(index, SCENARIOITEMSOURCE).value<ScenarioItem*>();
    if (index.column() > 0 || item == nullptr)
    {
        return;
    }
 
    if (index.parent().isValid())
    {
        if (index.parent().parent().isValid())
        {
            ApplicationInstancePtr appInstance = item->getApplicationInstance();
            appInstance->updateFound();
            if (!appInstance->getFound())
            {
                QMessageBox message;
                message.setText("Could not find Application " + item->data(0).toString() + " at " +
                                QString::fromStdString(appInstance->getPathToExecutable()) + ".");
                message.exec();
                if (!appInstance->getFound())
                {
                    updateModel();
                    emit updated();
                }
                return;
            }
 
            emit applicationInstanceClicked(appInstance, item);
        }
        else
        {
            return;
        }
    }
    else
    {
        emit scenarioClicked(item->getScenario());
    }
}
 
void
ScenarioListController::
    updateModel() //Scenarios don't have a setStatus-method, therefore UI should calculate Scenario status based on other
{
    ScenarioItem* rootItem = treemodel.getRootItem();
 
    for (const auto& package : *packages)
    {
        auto scenarios = package->getScenarios();
        for (const auto& scenario : *scenarios)
        {
            std::map<std::string, std::vector<ApplicationInstancePtr>> packageSubtrees;
            for (const auto& app : *scenario->getApplications())
            {
                std::string packageName = app->getPackageName();
 
                if (packageSubtrees.count(packageName) == 0)
                {
                    packageSubtrees[packageName] = std::vector<ApplicationInstancePtr>();
                }
                packageSubtrees[packageName].push_back(app);
            }
 
            ScenarioItem* scenarioItem;
            int index =
                findScenario(rootItem, scenario->getName(), scenario->getPackage()->getName());
            if (index == -1)
            {
                scenarioItem = new ScenarioItem(scenario);
 
                for (const auto& it : packageSubtrees)
                {
                    ScenarioItem* currentItem = new ScenarioItem(it.first, it.second);
                    scenarioItem->appendChild(currentItem);
                }
                treemodel.insertRow(0, scenarioItem);
            }
            else
            {
                scenarioItem = static_cast<ScenarioItem*>(rootItem->child(index));
 
                for (int i = 0; i < scenarioItem->childCount(); i++)
                {
                    ScenarioItem* subPackageItem =
                        static_cast<ScenarioItem*>(scenarioItem->child(i));
                    std::string name = subPackageItem->data(0).toString().toStdString();
 
                    std::vector<ApplicationInstancePtr> currentBuildSubtree = packageSubtrees[name];
                    ApplicationInstanceVectorPtr currentTreeSubtree =
                        subPackageItem->getApplicationInstances();
                    for (size_t k = 0; k < currentTreeSubtree->size(); k++)
                    {
                        bool found = false;
                        for (size_t j = 0; j < currentBuildSubtree.size(); j++)
                        {
                            if (currentTreeSubtree->at(k)->getName() ==
                                    currentBuildSubtree[j]->getName() &&
                                currentTreeSubtree->at(k)->getInstanceName() ==
                                    currentBuildSubtree[j]->getInstanceName())
                            {
                                found = true;
                                break;
                            }
                        }
                        if (!found)
                        {
                            treemodel.insertRow(
                                0,
                                new ScenarioItem(currentTreeSubtree->at(k)),
                                findSubScenarioModelIndex(scenario->getName(), name));
                        }
                    }
                }
            }
        }
    }
}
 
QModelIndex
ScenarioListController::findApplicationModelIndex(
    ScenarioManager::Data_Structure::ApplicationInstancePtr application)
{
    QModelIndex subScenarioModelIndex = findSubScenarioModelIndex(
        application->getScenario()->getName(), application->getPackageName());
    if (!subScenarioModelIndex.isValid())
    {
        return QModelIndex();
    }
    int count = 0;
    QModelIndex appIndex = subScenarioModelIndex.model()->index(0, 0);
    while (true)
    {
        appIndex = appIndex.sibling(count, 0);
        if (!appIndex.isValid())
        {
            return QModelIndex();
        }
        if (application->getInstanceName().empty())
        {
            if (application->getName() == appIndex.data().toString().toStdString())
            {
                return appIndex;
            }
        }
        else
        {
            if (application->getInstanceName() + "." + application->getName() ==
                appIndex.data().toString().toStdString())
            {
                return appIndex;
            }
        }
 
        count++;
    }
}
 
QModelIndex
ScenarioListController::findSubScenarioModelIndex(std::string scenarioName, std::string packageName)
{
    QModelIndex scenarioIndex = treemodel.index(0, 0);
 
    bool scenarioFound = false;
    int count = 0;
    while (!scenarioFound)
    {
        scenarioIndex = scenarioIndex.sibling(count, 0);
 
        if (!scenarioIndex.isValid())
        {
            return QModelIndex();
        }
        if (scenarioName == scenarioIndex.data().toString().toStdString())
        {
            scenarioFound = true;
            break;
        }
 
        count++;
    }
 
    count = 0;
    while (true)
    {
        QModelIndex currentSubPackageIndex = scenarioIndex.model()->index(count, 0);
        if (!currentSubPackageIndex.isValid())
        {
            return QModelIndex();
        }
        if (packageName == currentSubPackageIndex.data().toString().toStdString())
        {
            return currentSubPackageIndex;
        }
        count++;
    }
 
    return QModelIndex();
}
 
QModelIndex
ScenarioListController::findSubScenarioModelIndexByScenarioIndex(QModelIndex scenarioIndex,
                                                                 std::string packageName)
{
    int count = 0;
    while (true)
    {
        QModelIndex currentSubPackageIndex = scenarioIndex.model()->index(count, 0);
        if (packageName == currentSubPackageIndex.data().toString().toStdString())
        {
            return currentSubPackageIndex;
        }
        if (!currentSubPackageIndex.isValid())
        {
            return QModelIndex();
        }
        count++;
    }
 
    return QModelIndex();
}
 
//looks if the current scenario is already added
int
ScenarioListController::findScenario(ScenarioItem* rootItem,
                                     std::string name,
                                     std::string packageName)
{
    for (int i = 0; i < rootItem->childCount(); i++)
    {
        if (static_cast<ScenarioItem*>(rootItem->child(i))->getScenario()->getName() == name &&
            static_cast<ScenarioItem*>(rootItem->child(i))
                    ->getScenario()
                    ->getPackage()
                    ->getName() == packageName)
        {
            return i;
        }
    }
 
    return -1;
}
 
void
ScenarioListController::fetchStati()
{
    std::vector<ApplicationInstancePtr> apps;
    {
        std::unique_lock lock(applicationInstanceMutex);
        apps.swap(applicationInstances);
    }
    if (apps.empty())
    {
        return;
    }
    ApplicationInstanceStatusMap stati;
    IceUtil::Time start = IceUtil::Time ::now();
    //update all app instances and scenarios
    for (const ApplicationInstancePtr& appInst : apps)
    {
        std::string status = executor->getApplicationStatus(appInst);
        stati[appInst] = status;
    }
    ARMARX_DEBUG << deactivateSpam(5) << "Fetching scenario stati took "
                 << (IceUtil::Time::now() - start).toMilliSecondsDouble() << " ms";
    emit statusFetched(stati);
}
 
bool
ScenarioListController::StartScenario(ScenarioPtr scenario,
                                      ExecutorPtr executor,
                                      IceGrid::AdminPrx iceAdmin)
{
    // Make sure all required data files are generated when launching scenario
    const ApplicationInstanceVectorPtr applications = scenario->getApplications();
    ARMARX_CHECK_NOT_NULL(applications);
    for (ApplicationInstancePtr applicationInstance : *applications)
    {
        executor->loadAndSetCachedProperties(
            applicationInstance, Parser::IceParser::getCacheDir(), false, false);
        applicationInstance->load();
    }
 
    executor->setStarter(StarterFactory::getFactory()->getStarter(), scenario);
    executor->setStopStrategy(executor->getDefaultStopStrategy(), scenario);
 
    if (!scenario->allApplicationsFound())
    {
        ShowWarningDialog("Not all binaries in the Scenario " +
                              QString::fromStdString(scenario->getName()) + " could be found",
                          true,
                          QString::fromStdString(scenario->getName() + "BinariesMissing"));
        //            return false;
    }
    executor->startScenario(scenario);
    return true;
}
 
void
ScenarioListController::updateStati()
{
    //update all app instances and scenarios
    // but this needs to be done async -> first get list of applications,
    // then send these to other thread
    std::vector<ApplicationInstancePtr> apps;
    for (ScenarioManager::Data_Structure::PackagePtr& package : *packages)
    {
        ScenarioVectorPtr scenarios = package->getScenarios();
        for (const ScenarioPtr& scenario : *scenarios)
        {
            ApplicationInstanceVectorPtr appInsts = scenario->getApplications();
            for (const ApplicationInstancePtr& appInst : *appInsts)
            {
                apps.push_back(appInst);
            }
        }
    }
 
    {
        std::unique_lock lock(applicationInstanceMutex);
        apps.swap(applicationInstances);
    }
}
 
void
ScenarioListController::updateStati(ApplicationInstanceStatusMap stati)
{
    bool changed = false;
    for (auto& pair : stati)
    {
 
        bool statusChanged = pair.first->setStatus(pair.second);
        changed |= statusChanged;
    }
    //    ARMARX_DEBUG << deactivateSpam(5) << "Updating scenarios took " << (IceUtil::Time::now() - start).toMilliSecondsDouble() << " ms";
    if (changed)
    {
        auto start = IceUtil::Time ::now();
        treemodel.update();
        ARMARX_DEBUG << deactivateSpam(5) << "Updating scenario Model took "
                     << (IceUtil::Time::now() - start).toMilliSecondsDouble() << " ms";
    }
 
    emit statusUpdated();
}
 
void
ScenarioListController::saveScenario(
    ScenarioManager::Data_Structure::ApplicationInstancePtr application)
{
    for (const auto& package : *packages)
    {
        for (const auto& scenario : *package->getScenarios())
        {
            if (application->getScenario()->getName() == scenario->getName())
            {
                std::string cacheDir = Parser::IceParser::getCacheDir();
                executor->loadAndSetCachedProperties(application, cacheDir, false, false);
                qApp->processEvents();
 
                // only save the scenario itself, don't make each application save it's own config
                scenario->save(false);
                return;
            }
        }
    }
}
 
void
ScenarioListController::setIceAdmin(IceGrid::AdminPrx admin)
{
    iceAdmin = admin;
}
 
void
ScenarioListController::ShowWarningDialog(QString message, bool showOnce, QString messageId)
{
    static std::set<QString> dialogIds;
    if (showOnce)
    {
        ARMARX_CHECK_EXPRESSION(!messageId.isEmpty());
        if (dialogIds.count(messageId))
        {
            return;
        }
        dialogIds.insert(messageId);
    }
    QMessageBox box;
    box.setText(message);
    box.exec();
}