SystemStateMonitorWidget.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    ArmarX::Gui
 * @author     Jan Issac ( jan.issac at gmail dot com)
 * @date       2012
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "SystemStateMonitorWidget.h"
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/PostToObject.h>
 
#include <string>
#include <vector>
 
#include <QApplication>
#include <QLineEdit>
#include <QStyledItemDelegate>
#include <QVector>
 
#include <ArmarXCore/core/CoreObjectFactories.h>
#include <ArmarXCore/core/IceGridAdmin.h>
#include <ArmarXCore/core/util/OnScopeExit.h>
#include <ArmarXCore/interface/core/ArmarXManagerInterface.h>
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/ui_ArmarXManagerRepositoryDialog.h>
#include <ArmarXGui/libraries/ArmarXGuiBase/QtUtil.h>
#include <ArmarXGui/libraries/ArmarXGuiBase/widgets/InfixFilterModel.h>
 
namespace armarx
{
    class PropertyEditingDelegate : public QStyledItemDelegate
    {
    public:
        PropertyEditingDelegate(armarx::ManagerPrxMap* managerPrxMap,
                                std::mutex* managerPrxMapMutex,
                                QObject* parent = nullptr) :
            QStyledItemDelegate(parent),
            managerPrxMap(managerPrxMap),
            managerPrxMapMutex(managerPrxMapMutex)
        {
        }
 
        // QAbstractItemDelegate interface
        QWidget*
        createEditor(QWidget* parent,
                     const QStyleOptionViewItem& option,
                     const QModelIndex& index) const override
        {
            return new QLineEdit(parent);
        }
 
        void
        setEditorData(QWidget* editor, const QModelIndex& index) const override
        {
            QLineEdit* lineEdit = qobject_cast<QLineEdit*>(editor);
            if (!lineEdit)
            {
                return;
            }
 
            const QString cellText = index.data().toString();
            const int colonIndex = cellText.indexOf(":");
            if (colonIndex < 0)
            {
                // Not a "name : value" property row - editing it would truncate(-2)
                // and later push a corrupted property. Leave propertyName unset so
                // setModelData() below bails out.
                lineEdit->setText(cellText);
                return;
            }
 
            QString propValue = cellText;
            propValue.remove(0, colonIndex + 2);
            QString propName = cellText;
            propName.truncate(colonIndex - 1);
            lineEdit->setText(propValue);
            lineEdit->setProperty("propertyName", propName);
        }
 
        void
        setModelData(QWidget* editor,
                     QAbstractItemModel* model,
                     const QModelIndex& index) const override
        {
            QLineEdit* lineEdit = qobject_cast<QLineEdit*>(editor);
            if (!lineEdit)
            {
                return;
            }
 
            const QString propName = lineEdit->property("propertyName").toString();
            if (propName.isEmpty())
            {
                // setEditorData() found no "name : value" row; do not push anything.
                return;
            }
 
            model->setData(index, propName + " : " + lineEdit->text());
 
            armarx::ArmarXManagerInterfacePrx prx;
            {
                // Read the shared proxy map under its mutex (it is written from the
                // component-connect thread).
                std::unique_lock lock(*managerPrxMapMutex);
                auto it =
                    managerPrxMap->find(index.parent().parent().parent().data().toString());
                if (it != managerPrxMap->end())
                {
                    prx = it->second;
                }
            }
 
            if (!prx)
            {
                return;
            }
 
            try
            {
                prx->getPropertiesAdmin()
                    ->ice_collocationOptimized(false)
                    ->ice_timeout(1000)
                    ->setProperties({{propName.toStdString(), lineEdit->text().toStdString()}});
            }
            catch (...)
            {
                // Never let an Ice exception escape into the Qt event loop (std::terminate).
                ARMARX_WARNING << "Failed to set property " << propName.toStdString() << ": "
                               << GetHandledExceptionString();
            }
        }
 
    private:
        armarx::ManagerPrxMap* managerPrxMap;
        std::mutex* managerPrxMapMutex;
    };
 
    SystemStateMonitorWidget::SystemStateMonitorWidget()
    {
        setupModel();
        setupView();
        qRegisterMetaType<StateUpdateMap>("StateUpdateMap");
        qRegisterMetaType<ArmarXManagerItem::ManagerDataMap>("ArmarXManagerItem::ManagerDataMap");
        qRegisterMetaType<ArmarXManagerItem::ManagerData>("ArmarXManagerItem::ManagerData");
        qRegisterMetaType<ManagerPrxMap>("ManagerPrxMap");
 
 
        filterExpansionTimer.setSingleShot(true);
        connect(&filterExpansionTimer, SIGNAL(timeout()), this, SLOT(delayedFilterExpansion()));
        connect(ui.btnProblematicOnly,
                SIGNAL(toggled(bool)),
                this,
                SLOT(on_btnProblematicOnly_toggled(bool)),
                Qt::UniqueConnection);
 
        fillLegendLayout(ui.colorLegendLayout, *monitoredManagerModel);
    }
 
    SystemStateMonitorWidget::~SystemStateMonitorWidget()
    {
        //    stateUpdateTimer->stop();
        if (stateUpdateTask)
        {
            stateUpdateTask->stop();
        }
 
        delete managerRepositoryModel;
        delete monitoredManagerModel;
        //    delete stateUpdateTimer;
    }
 
    void
    SystemStateMonitorWidget::setupModel()
    {
        managerRepositoryModel = new ArmarXManagerModel();
        monitoredManagerModel = new ArmarXManagerModel();
    }
 
    void
    SystemStateMonitorWidget::setupView()
    {
        ui.setupUi(getWidget());
 
        managerRepositoryDialog = new ArmarXManagerRepositoryDialog(
            managerRepositoryModel, monitoredManagerModel, getWidget());
        managerRepositoryDialog->setModal(true);
        connect(managerRepositoryDialog, SIGNAL(accepted()), this, SLOT(acceptConfig()));
        connect(managerRepositoryDialog,
                SIGNAL(requestedManagerScan()),
                this,
                SLOT(retrieveOnlineManagers()));
        // Parent the delegate to the tree view: setItemDelegate() does not take
        // ownership, so an unparented delegate would leak.
        ui.monitoredManagersTree->setItemDelegate(new PropertyEditingDelegate(
            &currentManagerPrxMap, &managerPrxMapMutex, ui.monitoredManagersTree));
        filterModel = new InfixFilterModel(this);
        filterModel->addCustomFilter(
            [this](QAbstractItemModel* model, int source_row, const QModelIndex& source_parent)
            {
                QModelIndex index0 = model->index(source_row, 0, source_parent);
                if (this->ui.btnProblematicOnly->isChecked())
                {
                    auto variant =
                        index0.data((int)ArmarXManagerModel::UserDataRoles::ComponentStarted);
                    auto variantDependency =
                        index0.data((int)ArmarXManagerModel::UserDataRoles::ResolvedDependency);
                    if (variant.isValid())
                    {
                        //                ARMARX_INFO << "Checking entry: " << index0.data().toString() << " val: " << variant.toBool() << " param: " << hideResolvedComponents;
                        if (variant.toBool())
                        {
                            //                    ARMARX_INFO << "Resolve: Hiding " << index0.data().toString();
                            return false;
                        }
                    }
                    if (variantDependency.isValid())
                    {
                        if (variantDependency.toBool())
                        {
                            return false;
                        }
                    }
                    if (!variant.isValid() && !variantDependency.isValid())
                    {
                        return false;
                    }
                    //            ARMARX_INFO << "Showing entry: " << index0.data().toString() << " state: " <<
                    //                        (variantDependency.isValid() ? std::to_string(variantDependency.toBool()) : "none")
                    //                        << " - " << (variant.isValid() ? std::to_string(variant.toBool()) : "none");
                }
 
                return true;
            });
        filterModel->setSourceModel(monitoredManagerModel);
        filterModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
        ui.monitoredManagersTree->setModel(filterModel);
 
        connect(ui.lineEditFilter,
                SIGNAL(textChanged(QString)),
                filterModel,
                SLOT(setFilterFixedString(QString)));
        connect(ui.lineEditFilter,
                SIGNAL(textChanged(QString)),
                this,
                SLOT(expandFilterSelection(QString)),
                Qt::QueuedConnection);
 
        connect(ui.configureButton, SIGNAL(clicked()), this, SLOT(openManagerRepositoryDialog()));
 
        connect(this,
                SIGNAL(updateManagerStatesSignal(ArmarXManagerItem::ManagerDataMap)),
                this,
                SLOT(updateManagerStates(ArmarXManagerItem::ManagerDataMap)));
 
        //    stateUpdateTimer->start();
    }
 
    void
    SystemStateMonitorWidget::loadSettings(QSettings* settings)
    {
        managerRepositoryModel->populate(settings->value("ManagerRepository").toStringList());
 
        monitoredManagerModel->populate(settings->value("MonitoredManagers").toStringList());
        ui.monitoredManagersTree->expandToDepth(1);
    }
 
    void
    SystemStateMonitorWidget::saveSettings(QSettings* settings)
    {
        settings->setValue("ManagerRepository", managerRepositoryModel->toStringList());
 
        settings->setValue("MonitoredManagers", monitoredManagerModel->toStringList());
    }
 
    void
    SystemStateMonitorWidget::onInitComponent()
    {
        monitoredManagerModel->setIceManager(getIceManager());
        managerRepositoryModel->setIceManager(getIceManager());
    }
 
    void
    SystemStateMonitorWidget::onConnectComponent()
    {
        stateUpdateTask = new PeriodicTask<SystemStateMonitorWidget>(
            this,
            &SystemStateMonitorWidget::updateManagerObjectsState,
            500,
            false,
            "SystemStateMonitorUpdate");
        stateUpdateTask->setDelayWarningTolerance(5000);
        stateUpdateTask->start();
        if (monitoredManagerModel->empty()) // only if fresh connect without preconfig
        {
            prefillView();
        }
        else
        {
            // Restore proxies from a saved configuration. getManagerProxyMap() traverses
            // (and writes back into) the QStandardItemModel, so it must run on the GUI
            // thread; this slot runs on the component-connect thread. Marshal it there
            // (issue #64.8). Target `this` (the object the lambda dereferences), not
            // getWidget(), so Qt's queued-event lifetime guard protects it.
            postToObject(
                this,
                [this]()
                {
                    std::unique_lock lock(managerPrxMapMutex);
                    currentManagerPrxMap = monitoredManagerModel->getManagerProxyMap();
                });
        }
    }
 
    void
    SystemStateMonitorWidget::onDisconnectComponent()
    {
        if (stateUpdateTask)
        {
            stateUpdateTask->stop();
        }
    }
 
    void
    SystemStateMonitorWidget::onExitComponent()
    {
        if (stateUpdateTask)
        {
            stateUpdateTask->stop();
        }
    }
 
    void
    SystemStateMonitorWidget::updateManagerStates(
        const ArmarXManagerItem::ManagerDataMap& managerData)
    {
        CHECK_QT_THREAD(getWidget());
 
        std::unique_lock lock(monitoredManagerModel->getMutex());
 
        monitoredManagerModel->updateManagerDetails(managerData);
        filterModel->invalidate();
    }
 
    bool
    SystemStateMonitorWidget::retrieveManagerData(ArmarXManagerInterfacePrx prx,
                                                  ArmarXManagerItem::ManagerData& managerData)
    {
        CHECK_NOT_QT_THREAD(getWidget());
        // Start true so the &= below actually reflects retrieveManagerObjectsState().
        // (Previously initialised to false, which made this function always return false
        // and reported managers as online even when their ice_ping failed - issue #64.2.)
        bool result = true;
        try
        {
            managerData.proxy = prx;
            prx = prx->ice_timeout(1000);
            managerData.name = QString::fromStdString(prx->ice_getIdentity().name);
            managerData.appProperties = prx->getApplicationPropertyInfos();
            result &= retrieveManagerObjectsState(prx, managerData.objects);
            try
            {
                managerData.connection = prx->ice_collocationOptimized(false)->ice_getConnection();
                managerData.endpointStr =
                    managerData.connection
                        ? QString::fromStdString(managerData.connection->getEndpoint()->toString())
                        : "Endpoint: no connection data";
            }
 
            catch (const IceUtil::Exception& ex)
            {
                //            ARMARX_INFO << deactivateSpam(5, managerData.name.toStdString()) << "Failed to get connection info for " << managerData.name.toStdString();
                managerData.endpointStr =
                    QString::fromStdString("? (" + std::string(ex.ice_id()) + ")");
            }
            // Reflect the ice_ping result: a manager whose ping failed is not online,
            // even if getApplicationPropertyInfos() happened to succeed (issue #64.2).
            managerData.online = result;
        }
        catch (...)
        {
            managerData.online = false;
            result = false;
        }
        return result;
    }
 
    bool
    SystemStateMonitorWidget::retrieveManagerObjectsState(
        ArmarXManagerInterfacePrx prx,
        ArmarXManagerItem::ObjectMap& objectStates)
    {
        CHECK_NOT_QT_THREAD(getWidget());
        // Bound every call with a timeout, not just the ping below: a component that
        // accepts connections but then hangs in dispatch would otherwise stall the whole
        // update task forever (issue #64.6).
        prx = prx->ice_timeout(1000);
 
        // update existence state
        try
        {
            prx->ice_ping();
        }
        catch (...)
        {
            return false;
        }
 
        // actual retrieval
        Ice::StringSeq objectNames = prx->getManagedObjectNames();
 
        for (auto& objectName : objectNames)
        {
            ManagedIceObjectItem objEntry;
            objEntry.name = objectName.c_str();
            objEntry.state = prx->getObjectState(objectName);
            objEntry.connectivity = prx->getObjectConnectivity(objectName);
            objEntry.properties = prx->getObjectPropertyInfos(objectName);
            try
            {
                objEntry.metaInfoMap = prx->getMetaInfo(objectName);
            }
            catch (...)
            {
                ARMARX_INFO << deactivateSpam(1000, objectName) << "Failed to get meta info for "
                            << objectName;
            }
            objectStates[objEntry.name] = (objEntry);
        }
 
        return true;
    }
 
    void
    SystemStateMonitorWidget::updateManagerObjectsState()
    {
 
        //    std::unique_lock lock(monitoredManagerModel->getMutex());
        //    StateUpdateMap stateMap;
        ArmarXManagerItem::ManagerDataMap managerDataMap;
        {
            decltype(currentManagerPrxMap) proxies;
            {
                std::unique_lock lock(managerPrxMapMutex);
                proxies = currentManagerPrxMap;
            }
            IceUtil::Time start = IceUtil::Time::now();
            for (auto it = proxies.begin(); it != proxies.end(); it++)
            {
                // retrieveManagerData() already retrieves the object states, the app
                // properties, the connection info and the online flag. The previous code
                // fetched the object states and app properties here as well and then
                // discarded them by calling retrieveManagerData() - doing every Ice call
                // twice per manager per tick (issue #64.6).
                managerDataMap[it->first].name = it->first;
                retrieveManagerData(it->second, managerDataMap[it->first]);
            }
            ARMARX_DEBUG << "update duration: "
                         << (IceUtil::Time::now() - start).toMilliSecondsDouble();
        }
 
        emit updateManagerStatesSignal(managerDataMap);
    }
 
    void
    SystemStateMonitorWidget::acceptConfig()
    {
        this->managerRepositoryModel->copyFrom(
            managerRepositoryDialog->getManagerRepositoryModel());
 
        this->monitoredManagerModel->copyFrom(managerRepositoryDialog->getMonitoredManagersModel());
        ui.monitoredManagersTree->expandToDepth(1);
        std::unique_lock lock(managerPrxMapMutex);
        currentManagerPrxMap = monitoredManagerModel->getManagerProxyMap();
    }
 
    QStringList
    SystemStateMonitorWidget::fetchOnlineManagers()
    {
        // Liveness-ping timeout in milliseconds. This is a read-only monitor: a manager
        // that does not answer within this budget is treated as "unknown" and simply not
        // listed. It is never removed from the registry (see issue #64) - a monitor must
        // not mutate what it monitors. Kept modest because the Scan/Configure callers run
        // this synchronously on the GUI thread, where each unreachable manager blocks the
        // UI for this long.
        const int pingTimeoutMs = 1000;
 
        enableMainWidgetAsync(false);
        ARMARX_ON_SCOPE_EXIT
        {
            enableMainWidgetAsync(true);
        };
 
        auto admin = getIceManager()->getIceGridSession()->getAdmin();
        ARMARX_INFO << "Getting managers";
        IceGrid::ObjectInfoSeq objects = admin->getAllObjectInfos("*Manager");
        ARMARX_INFO << "Got new managers";
 
        IceGrid::ObjectInfoSeq result;
 
        for(const auto& objectInfo : objects)
        {
            Ice::ObjectPrx current = objectInfo.proxy;
 
            ArmarXManagerInterfacePrx object;
 
            // if objects are hanging we might get connection refused
            try
            {
                const std::string proxyName = current->ice_getIdentity().name;
                ARMARX_INFO << "Trying to ping proxy " << VAROUT(proxyName);
                object = ArmarXManagerInterfacePrx::checkedCast(current->ice_timeout(pingTimeoutMs));
                ARMARX_INFO << "Ping received from " << VAROUT(proxyName);
            }
            catch (...)
            {
                // Timeout / connection refused: the manager is busy, slow, or gone. Treat
                // it as unknown and skip it. Do not remove it from the registry.
                ARMARX_INFO << GetHandledExceptionString();
                continue;
            }
 
            // checkedCast returns null (without throwing) for objects that match the
            // "*Manager" pattern but are not ArmarXManagers, e.g. IceStorm/TopicManager.
            if (object)
            {
                result.push_back(objectInfo);
            }
        }
        ARMARX_INFO << "Iterated through online managers";
 
        QStringList managers;
        for (const IceGrid::ObjectInfo& info : result)
        {
            managers.append(info.proxy->ice_getIdentity().name.c_str());
        }
 
        return managers;
    }
 
    void
    SystemStateMonitorWidget::retrieveOnlineManagers()
    {
        managerRepositoryDialog->addOnlineManagers(fetchOnlineManagers());
    }
 
    void
    SystemStateMonitorWidget::openManagerRepositoryDialog()
    {
        managerRepositoryDialog->getManagerRepositoryModel()->copyFrom(managerRepositoryModel);
 
        managerRepositoryDialog->getMonitoredManagersModel()->copyFrom(monitoredManagerModel);
 
        retrieveOnlineManagers();
 
        managerRepositoryDialog->show();
    }
 
    void
    SystemStateMonitorWidget::prefillView()
    {
        managerRepositoryModel->clear();
        monitoredManagerModel->clear();
 
        QStringList managers = fetchOnlineManagers();
        //    enableMainWidgetAsync(false);
        //    ARMARX_INFO << "Got managers";
        //    QMetaObject::invokeMethod(this, "addArmarXManagers", Q_ARG(QStringList, managers));
        addArmarXManagers(managers);
        QMetaObject::invokeMethod(ui.monitoredManagersTree, "expandToDepth", Q_ARG(int, 0));
        std::unique_lock lock(managerPrxMapMutex);
        currentManagerPrxMap = monitoredManagerModel->getManagerProxyMap(managers);
    }
 
 
    void
    SystemStateMonitorWidget::addArmarXManagers(QStringList managerNames)
    {
        //    ARMARX_IMPORTANT << this->rowCount();
        for (auto& name : managerNames)
        {
            try
            {
                ArmarXManagerItem::ManagerData data;
                data.name = name;
                ARMARX_DEBUG << name.toStdString();
                auto proxy =
                    getIceManager()->getProxy<ArmarXManagerInterfacePrx>(name.toStdString());
                retrieveManagerData(proxy, data);
                QMetaObject::invokeMethod(monitoredManagerModel,
                                          "upsertManagerDetails",
                                          Q_ARG(ArmarXManagerItem::ManagerData, data));
                ARMARX_DEBUG << name.toStdString() << " done";
            }
            catch (...)
            {
                armarx::handleExceptions();
            }
        }
    }
 
    void
    SystemStateMonitorWidget::expandFilterSelection(QString filterStr)
    {
        ARMARX_DEBUG_S << VAROUT(filterStr);
        if (filterStr.length() == 0)
        {
            ui.monitoredManagersTree->collapseAll();
            //        ui.monitoredManagersTree->expandToDepth(1);
        }
        else
        {
            filterExpansionTimer.start(500);
        }
    }
 
    void
    SystemStateMonitorWidget::delayedFilterExpansion()
    {
        CHECK_QT_THREAD(getWidget());
 
        InfixFilterModel::ExpandFilterResults(ui.monitoredManagersTree);
    }
 
    void
    armarx::SystemStateMonitorWidget::on_btnProblematicOnly_toggled(bool checked)
    {
        CHECK_QT_THREAD(getWidget());
 
        //    filterModel->setHideResolvedComponents(checked);
        filterModel->invalidate();
        InfixFilterModel::ExpandFilterResults(ui.monitoredManagersTree);
    }
 
    void
    SystemStateMonitorWidget::fillLegendLayout(QHBoxLayout* layout, ArmarXManagerModel& model) const
    {
        auto addLegendEntry = [layout, &model](ManagedIceObjectState state, const QString& text)
        {
            QLabel* label = new QLabel(text);
            {
                QBrush brush = model.getBrush(state);
                QPalette p = label->palette();
                p.setColor(label->backgroundRole(), brush.color());
                label->setPalette(p);
                label->setAutoFillBackground(true);
            }
            {
                QFont font = label->font();
                font.setPointSize(10);
                label->setFont(font);
            }
            layout->addWidget(label);
        };
 
        addLegendEntry(armarx::eManagedIceObjectCreated, "Created");
        addLegendEntry(armarx::eManagedIceObjectInitializing, "Initializing");
        addLegendEntry(armarx::eManagedIceObjectInitialized, "Initialized");
        addLegendEntry(armarx::eManagedIceObjectInitializationFailed, "Initialization Failed");
        addLegendEntry(armarx::eManagedIceObjectStarting, "Connecting");
        addLegendEntry(armarx::eManagedIceObjectStarted, "Connected");
        addLegendEntry(armarx::eManagedIceObjectStartingFailed, "Connecting Failed");
        addLegendEntry(armarx::eManagedIceObjectExiting, "Exiting");
        addLegendEntry(armarx::eManagedIceObjectExited, "Exited");
    }
 
} // namespace armarx