IceGridViewer.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     Manfred Kroehnert ( Manfred.Kroehnert at kit dot edu)
* @date       2013
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "IceGridViewer.h"
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/PostToObject.h>
 
#include <algorithm>
 
#include <Ice/ObjectAdapter.h>
 
#include <ArmarXCore/core/IceGridAdmin.h>
#include <ArmarXCore/core/exceptions/LocalException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/ui_IceGridNodeView.h>
#include <ArmarXGui/gui-plugins/SystemStateMonitorPlugin/ui_IceGridViewer.h>
 
#include "NodeObserver.h"
#include "model/AdapterInfoModel.h"
#include "model/NodeInfoModel.h"
#include "model/ServerInfoModel.h"
 
namespace armarx
{
    IceGridViewer::IceGridViewer() :
        ui(new Ui::IceGridViewer), ADAPTER_NAME("IceGridNodeObserverGui")
    {
        ui->setupUi(getWidget());
 
        qRegisterMetaType<QVector<int>>("QVector<int>");
        qRegisterMetaType<IceGrid::ServerDynamicInfo>("IceGrid::ServerDynamicInfo");
        connect(ui->gridNodeSelector,
                SIGNAL(currentIndexChanged(int)),
                this,
                SLOT(selectGridNode(int)));
 
        // Stack-allocated: the generated Ui holder is only needed to wire up the table
        // views (which become children of contentWidget); the old heap allocation was
        // never deleted (issue #64.16).
        Ui::IceGridNodeView content;
        content.setupUi(ui->contentWidget);
        nodeInfoModel = new NodeInfoModel;
        content.NodeInfo->setModel(nodeInfoModel);
        serverInfoModel = new ServerInfoModel;
        content.ServerInfo->setModel(serverInfoModel);
        adapterInfoModel = new AdapterInfoModel;
        content.AdapterInfo->setModel(adapterInfoModel);
 
        connect(serverInfoModel,
                SIGNAL(serverInfoChanged(IceGrid::ServerDynamicInfo)),
                this,
                SLOT(serverInfoChanged(IceGrid::ServerDynamicInfo)));
 
        selectorModel = new QStringListModel;
        ui->gridNodeSelector->setModel(selectorModel);
    }
 
    IceGridViewer::~IceGridViewer()
    {
        // The four models were unparented and leaked; delete them here (issue #64.16).
        // Views still bound to them detach safely via Qt's model destroyed() handling.
        delete ui;
        delete nodeInfoModel;
        delete serverInfoModel;
        delete adapterInfoModel;
        delete selectorModel;
    }
 
    void
    IceGridViewer::loadSettings(QSettings* settings)
    {
    }
 
    void
    IceGridViewer::saveSettings(QSettings* settings)
    {
    }
 
    void
    IceGridViewer::onInitComponent()
    {
        // create new IceGridAdmin which also creates a new AdminSession
        // Observers set on this new session won't interfer with the default observers
        // used for tracking ManagedIceObject dependencies
        iceGridAdmin = IceGridAdmin::Create(getIceManager()->getCommunicator(), ADAPTER_NAME);
        // remove default observers which are not required and used here
        iceGridAdmin->removeObservers();
    }
 
    void
    IceGridViewer::onConnectComponent()
    {
        IceGrid::AdminSessionPrx adminSession = iceGridAdmin->adminSession();
 
        QtNodeObserverPtr observer = new QtNodeObserver(this);
        Ice::ObjectPrx objectProxy =
            iceGridAdmin->registerObjectWithNewAdapter(observer, ADAPTER_NAME, observerAdapter);
        IceGrid::NodeObserverPrx nodeObserver = IceGrid::NodeObserverPrx::checkedCast(objectProxy);
 
        // The first setObservers(NULL, ...) call was immediately overwritten by the next
        // line and did nothing (issue #64.19).
        adminSession->setObservers(nullptr, nodeObserver, nullptr, nullptr, nullptr);
    }
 
    void
    IceGridViewer::onExitComponent()
    {
        // stop updating the AdminSession so it can be removed
        iceGridAdmin->stop();
        // remove observers so the IceGridAmin does not hold any more references to them
        iceGridAdmin->adminSession()->setObservers(NULL, NULL, NULL, NULL, NULL);
        // destroy the object adapter to remove the observer objects
        observerAdapter->destroy();
    }
 
    void
    IceGridViewer::gridNodeListUpdate(const IceGrid::NodeDynamicInfoSeq& nodeSeq)
    {
        // Called from the Ice dispatch thread. Marshal all model/widget access onto the
        // GUI thread (this object's thread). Everything below then runs single-threaded,
        // which is why gridNodeList needs no mutex (see issue #64.8/#64.9). The captured
        // arguments are copies, so they stay valid after the Ice call returns.
        postToObject(
            this,
            [this, nodeSeq]()
            {
                const QString lastSelectionText = ui->gridNodeSelector->currentText();
 
                gridNodeList = nodeSeq;
                QStringList nodeNames;
                for (const auto& node : gridNodeList)
                {
                    nodeNames.append(QString::fromStdString(node.info.name));
                }
                selectorModel->setStringList(nodeNames);
 
                const int index = std::max(0, ui->gridNodeSelector->findText(lastSelectionText));
                ui->gridNodeSelector->setCurrentIndex(index);
                selectGridNode(index);
            });
    }
 
    void
    IceGridViewer::gridNodeListAdd(const IceGrid::NodeDynamicInfo& node)
    {
        postToObject(
            this,
            [this, node]()
            {
                QStringList currentEntries = selectorModel->stringList();
                currentEntries.append(QString::fromStdString(node.info.name));
                gridNodeList.push_back(node);
                selectorModel->setStringList(currentEntries);
            });
    }
 
    void
    IceGridViewer::gridNodeListRemove(const QString& node)
    {
        postToObject(
            this,
            [this, node]()
            {
                const QString lastSelectionText = ui->gridNodeSelector->currentText();
 
                QStringList currentEntries = selectorModel->stringList();
                currentEntries.removeOne(node);
 
                // issue #64.10: the old hand-written erase loop advanced past the erased
                // element (and past end() when it was the last one). Use erase-remove_if.
                const std::string nodeName = node.toStdString();
                gridNodeList.erase(std::remove_if(gridNodeList.begin(),
                                                  gridNodeList.end(),
                                                  [&nodeName](const IceGrid::NodeDynamicInfo& info)
                                                  { return info.info.name == nodeName; }),
                                   gridNodeList.end());
 
                selectorModel->setStringList(currentEntries);
 
                const int index =
                    std::max<int>(0, ui->gridNodeSelector->findText(lastSelectionText));
                ui->gridNodeSelector->setCurrentIndex(index);
                selectGridNode(index);
            });
    }
 
    void
    IceGridViewer::updateServerInfo(const std::string& nodeName,
                                    const IceGrid::ServerDynamicInfo& serverUpdateInfo)
    {
        postToObject(
            this,
            [this, nodeName, serverUpdateInfo]()
            {
                auto nodeEntry = std::find_if(gridNodeList.begin(),
                                              gridNodeList.end(),
                                              [&nodeName](const IceGrid::NodeDynamicInfo& nodeInfo)
                                              { return nodeName == nodeInfo.info.name; });
                if (nodeEntry == gridNodeList.end())
                {
                    return;
                }
 
                auto serverEntry =
                    std::find_if(nodeEntry->servers.begin(),
                                 nodeEntry->servers.end(),
                                 [&serverUpdateInfo](const IceGrid::ServerDynamicInfo& serverInfo)
                                 { return serverUpdateInfo.id == serverInfo.id; });
 
                if (serverEntry == nodeEntry->servers.end())
                {
                    nodeEntry->servers.push_back(serverUpdateInfo);
                }
                else if (serverUpdateInfo.pid == 0)
                {
                    nodeEntry->servers.erase(serverEntry);
                }
                else
                {
                    *serverEntry = serverUpdateInfo;
                }
 
                selectGridNode(ui->gridNodeSelector->currentIndex());
            });
    }
 
    void
    IceGridViewer::updateAdapterInfo(const std::string& nodeName,
                                     const IceGrid::AdapterDynamicInfo& adapterUpdateInfo)
    {
        postToObject(
            this,
            [this, nodeName, adapterUpdateInfo]()
            {
                auto nodeEntry = std::find_if(gridNodeList.begin(),
                                              gridNodeList.end(),
                                              [&nodeName](const IceGrid::NodeDynamicInfo& nodeInfo)
                                              { return nodeName == nodeInfo.info.name; });
                if (nodeEntry == gridNodeList.end())
                {
                    return;
                }
 
                auto adapterEntry = std::find_if(
                    nodeEntry->adapters.begin(),
                    nodeEntry->adapters.end(),
                    [&adapterUpdateInfo](const IceGrid::AdapterDynamicInfo& adapterInfo)
                    { return adapterUpdateInfo.id == adapterInfo.id; });
 
                if (adapterEntry == nodeEntry->adapters.end())
                {
                    // A null proxy signals adapter deactivation. If we never saw this
                    // adapter activate there is nothing to add - and storing the null
                    // proxy would later crash AdapterInfoModel::data() on repaint
                    // (issue #64.11).
                    if (adapterUpdateInfo.proxy)
                    {
                        nodeEntry->adapters.push_back(adapterUpdateInfo);
                    }
                }
                else if (!adapterUpdateInfo.proxy)
                {
                    nodeEntry->adapters.erase(adapterEntry);
                }
                else
                {
                    *adapterEntry = adapterUpdateInfo;
                }
 
                selectGridNode(ui->gridNodeSelector->currentIndex());
            });
    }
 
    void
    IceGridViewer::serverInfoChanged(IceGrid::ServerDynamicInfo serverInfo)
    {
        try
        {
            iceGridAdmin->getAdmin()->enableServer(serverInfo.id, serverInfo.enabled);
        }
        catch (...)
        {
            // Blocking Ice call on the GUI thread (triggered by the Enabled checkbox in
            // ServerInfoModel). Never let an Ice exception escape into the Qt event loop
            // (issue #64.12d).
            ARMARX_WARNING << "Failed to enable/disable server " << serverInfo.id << ": "
                           << GetHandledExceptionString();
        }
    }
 
    void
    IceGridViewer::selectGridNode(int index)
    {
        // Runs on the GUI thread only: as a slot of ui->gridNodeSelector and from the
        // marshaled observer handlers above. gridNodeList is therefore single-threaded
        // and needs no lock (issue #64.9).
        if (index < 0 || index >= (int)gridNodeList.size())
        {
            return;
        }
 
        nodeInfoModel->setData(gridNodeList[index].info);
        serverInfoModel->setData(gridNodeList[index].servers);
        adapterInfoModel->setData(gridNodeList[index].adapters);
    }
} // namespace armarx