ThreadViewer.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* 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::
* @author     Mirko Waechter ( mirko.waechter at kit dot edu)
* @date       2013
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "ThreadViewer.h"
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/PostToObject.h>
 
#include <QSettings>
 
#include <ArmarXCore/core/IceGridAdmin.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/services/tasks/ThreadList.h>
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/ui_ThreadViewer.h>
 
#include "ProgressbarDelegate.h"
#include "RunningTaskModel.h"
#include "ThreadViewerModel.h"
 
namespace armarx
{
    ThreadViewer::ThreadViewer() :
        periodicTaskModel(0), runningTaskModel(0), ui(new Ui::ThreadViewer)
 
    {
        ui->setupUi(getWidget());
 
        periodicTaskModel = new ThreadViewerModel(getWidget());
 
        ui->threadListView->setModel(periodicTaskModel);
        ui->threadListView->setItemDelegateForColumn(3,
                                                     new ProgressbarDelegate(ui->threadListView));
 
        // No setColumnWidth() here: setResizeMode(Stretch) discards fixed widths
        // (issue #64.14d).
        ui->threadListView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
 
        runningTaskModel = new RunningTaskModel(getWidget());
 
        ui->runningTaskView->setModel(runningTaskModel);
        ui->runningTaskView->setItemDelegateForColumn(
            2, new ProgressbarDelegate(ui->runningTaskView));
 
        ui->runningTaskView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
 
        QFont font;
        font.setPointSize(8);
        ui->threadListView->setFont(font);
        ui->runningTaskView->setFont(font);
 
        connect(this,
                SIGNAL(threadManagerListUpdated(QStringList)),
                this,
                SLOT(updateThreadManagerList(QStringList)));
        connect(this, SIGNAL(cpuUsageValueUpdated(int)), this, SLOT(cpuUsageValueSet(int)));
        connect(ui->cbThreadListManager,
                SIGNAL(currentIndexChanged(QString)),
                this,
                SLOT(managedSelectionChanged(QString)));
        connect(ui->btnRefresh, SIGNAL(clicked()), this, SLOT(triggerThreadManagerListUpdate()));
    }
 
    ThreadViewer::~ThreadViewer()
    {
        delete ui;
    }
 
    void
    ThreadViewer::loadSettings(QSettings* settings)
    {
        // Restore the previously selected thread-manager; applied in
        // updateThreadManagerList() once the list has been populated (issue #64.14f).
        restoredSelection = settings->value("ThreadViewer/selectedManager").toString();
    }
 
    void
    ThreadViewer::saveSettings(QSettings* settings)
    {
        settings->setValue("ThreadViewer/selectedManager", ui->cbThreadListManager->currentText());
    }
 
    void
    ThreadViewer::onInitComponent()
    {
    }
 
    void
    ThreadViewer::onConnectComponent()
    {
 
        retrieveThreadManagerList();
        periodicTask =
            new PeriodicTask<ThreadViewer>(this, &ThreadViewer::runThreadManagerUpdate, 500);
        periodicTask->start();
    }
 
    void
    ThreadViewer::onExitComponent()
    {
        if (periodicTask)
        {
            periodicTask->stop();
        }
 
        if (managerUpdateTask)
        {
            managerUpdateTask->stop();
        }
    }
 
    void
    ThreadViewer::triggerThreadManagerListUpdate()
    {
        if (managerUpdateTask && managerUpdateTask->isRunning())
        {
            return;
        }
 
        ui->btnRefresh->setEnabled(false);
        ui->btnRefresh->setToolTip("Refreshing manager list...please wait");
        managerUpdateTask =
            new RunningTask<ThreadViewer>(this, &ThreadViewer::retrieveThreadManagerList);
        managerUpdateTask->start();
    }
 
    void
    ThreadViewer::retrieveThreadManagerList()
    {
        std::vector<std::string> managerList;
        QStringList qManagerList;
 
        try
        {
            if (getIceManager() && getIceManager()->getIceGridSession())
                managerList = getIceManager()
                                  ->getIceGridSession()
                                  ->getRegisteredObjectNames<ThreadListInterfacePrx>("*ThreadList");
 
            for (unsigned int i = 0; i < managerList.size(); ++i)
            {
                qManagerList << QString::fromStdString(managerList.at(i));
            }
        }
        catch (...)
        {
            // Do not rethrow: this runs in a RunningTask body, where an escaping
            // exception would tear down the task thread (issue #64.14e). The emit
            // re-enables the refresh button.
            emit threadManagerListUpdated(qManagerList);
            return;
        }
 
        emit threadManagerListUpdated(qManagerList);
    }
 
    void
    ThreadViewer::updateThreadManagerList(QStringList list)
    {
        const QString lastSelectionText = ui->cbThreadListManager->currentText();
        ui->cbThreadListManager->clear();
        ui->cbThreadListManager->addItems(list);
 
        // A still-pending persisted selection takes priority until its manager actually
        // appears in the list - it may not have been registered on the first refresh
        // (issue #64.14f). Once applied, clear it so later refreshes (and the user's own
        // choices) are respected.
        int index = -1;
        if (!restoredSelection.isEmpty())
        {
            index = ui->cbThreadListManager->findText(restoredSelection);
            if (index >= 0)
            {
                restoredSelection.clear();
            }
        }
        if (index < 0)
        {
            index = ui->cbThreadListManager->findText(lastSelectionText);
        }
 
        // >= 0, not > 0: index 0 is a valid entry that the old check silently dropped
        // (issue #64.14c).
        if (index >= 0)
        {
            ui->cbThreadListManager->setCurrentIndex(index);
        }
 
        ui->btnRefresh->setEnabled(true);
        ui->btnRefresh->setToolTip("Refresh the thread manager list");
    }
 
    void
    ThreadViewer::managedSelectionChanged(QString selectedString)
    {
        if (selectedString.size() == 0)
        {
            return;
        }
 
        // Resolve the proxy without holding proxyMutex: getProxy() can block, and holding
        // the lock across it would stall the periodic update task, freezing the GUI on a
        // drop-down change (issue #64.14a).
        auto proxy = getProxy<ThreadListInterfacePrx>(selectedString.toStdString());
        {
            std::unique_lock lock(proxyMutex);
            threadManagerProxy = proxy;
        }
        ARMARX_VERBOSE << "new proxy for ThreadViewerModel set: " << selectedString;
    }
 
    void
    ThreadViewer::cpuUsageValueSet(int value)
    {
 
        ui->cpuUsageProgressBar->setValue(value);
    }
 
    void
    ThreadViewer::runThreadManagerUpdate()
    {
        // Copy the proxy under the lock, then release it before any blocking Ice call so
        // managedSelectionChanged() (GUI thread) never waits on this task's network I/O
        // (issue #64.14a).
        ThreadListInterfacePrx proxy;
        {
            std::unique_lock lock(proxyMutex);
            proxy = threadManagerProxy;
        }
 
        if (!proxy)
        {
            return;
        }
 
        try
        {
            PeriodicTaskList periodicTaskList = proxy->getPeriodicTasks();
            RunningTaskList runningTaskList = proxy->getRunningTasks();
            Ice::Double cpuProcTotalTime = proxy->getCpuUsage();
            int value = static_cast<int>(cpuProcTotalTime);
 
            // Qt models must be mutated on the GUI thread; this runs on a PeriodicTask
            // worker thread (issue #64.8). Target `this` (the controller, which the lambda
            // dereferences), not getWidget(): Qt cancels a queued call whose target object
            // is destroyed, so targeting the object the lambda uses avoids a use-after-free.
            postToObject(
                this,
                [this, periodicTaskList, runningTaskList]()
                {
                    periodicTaskModel->setPeriodicTaskListData(periodicTaskList);
                    runningTaskModel->setRunningTaskListData(runningTaskList);
                });
            emit cpuUsageValueUpdated(value);
        }
        catch (...)
        {
            // The component may have gone away between ticks. Swallow all Ice exceptions;
            // the old code caught only three types, so TimeoutException,
            // ConnectionRefusedException, CloseConnectionException etc. escaped the
            // PeriodicTask callback (issue #64.14b).
        }
    }
} // namespace armarx