peertablemodel.cpp

Go to the documentation of this file.

// Copyright (c) 2011-2013 The Bitcoin developers
// Copyright (c) 2017-2020 The PIVX Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include "peertablemodel.h"
 
#include "clientmodel.h"
#include "guiconstants.h"
#include "guiutil.h"
#include "net.h"
#include "sync.h"
#include "validation.h"  // cs_main
 
#include <algorithm>
 
#include <QDebug>
#include <QList>
#include <QTimer>
 
bool NodeLessThan::operator()(const CNodeCombinedStats& left, const CNodeCombinedStats& right) const
{
    const CNodeStats* pLeft = &(left.nodeStats);
    const CNodeStats* pRight = &(right.nodeStats);
 
    if (order == Qt::DescendingOrder)
        std::swap(pLeft, pRight);
 
    switch(column) {
    case PeerTableModel::NetNodeId:
        return pLeft->nodeid < pRight->nodeid;
    case PeerTableModel::Address:
        return pLeft->addrName.compare(pRight->addrName) < 0;
    case PeerTableModel::Subversion:
        return pLeft->cleanSubVer.compare(pRight->cleanSubVer) < 0;
    case PeerTableModel::Ping:
        return pLeft->dPingTime < pRight->dPingTime;
    }
 
    return false;
}
 
// private implementation
class PeerTablePriv
{
public:
    QList<CNodeCombinedStats> cachedNodeStats;
    int sortColumn;
    Qt::SortOrder sortOrder;
    std::map<NodeId, int> mapNodeRows;
 
    void refreshPeers()
    {
        {
            cachedNodeStats.clear();
            std::vector<CNodeStats> vstats;
            if(g_connman)
                g_connman->GetNodeStats(vstats);
            cachedNodeStats.reserve(vstats.size());
            for (const CNodeStats& nodestats : vstats) {
                CNodeCombinedStats stats;
                stats.nodeStateStats.nMisbehavior = 0;
                stats.nodeStateStats.nSyncHeight = -1;
                stats.nodeStateStats.nCommonHeight = -1;
                stats.fNodeStateStatsAvailable = false;
                stats.nodeStats = nodestats;
                cachedNodeStats.append(stats);
            }
        }
 
        // Try to retrieve the CNodeStateStats for each node.
        {
            TRY_LOCK(cs_main, lockMain);
            if (lockMain) {
                for (CNodeCombinedStats& stats : cachedNodeStats)
                    stats.fNodeStateStatsAvailable = GetNodeStateStats(stats.nodeStats.nodeid, stats.nodeStateStats);
            }
        }
 
        if (sortColumn >= 0)
            // sort cacheNodeStats (use stable sort to prevent rows jumping around unnecessarily)
            std::stable_sort(cachedNodeStats.begin(), cachedNodeStats.end(), NodeLessThan(sortColumn, sortOrder));
 
        // build index map
        mapNodeRows.clear();
        int row = 0;
        for (const CNodeCombinedStats& stats : cachedNodeStats)
            mapNodeRows.emplace(stats.nodeStats.nodeid, row++);
    }
 
    int size()
    {
        return cachedNodeStats.size();
    }
 
    CNodeCombinedStats* index(int idx)
    {
        if (idx >= 0 && idx < cachedNodeStats.size()) {
            return &cachedNodeStats[idx];
        } else {
            return 0;
        }
    }
};
 
PeerTableModel::PeerTableModel(ClientModel* parent) : QAbstractTableModel(parent),
                                                      clientModel(parent),
                                                      timer(0)
{
    columns << tr("NodeID") << tr("Address/Hostname") << tr("Version") << tr("Ping Time");
    priv = new PeerTablePriv();
    // default to unsorted
    priv->sortColumn = -1;
 
    // set up timer for auto refresh
    timer = new QTimer();
    connect(timer, &QTimer::timeout, this, &PeerTableModel::refresh);
    timer->setInterval(MODEL_UPDATE_DELAY);
 
    // load initial data
    refresh();
}
 
void PeerTableModel::startAutoRefresh()
{
    timer->start();
}
 
void PeerTableModel::stopAutoRefresh()
{
    timer->stop();
}
 
int PeerTableModel::rowCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent);
    return priv->size();
}
 
int PeerTableModel::columnCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent);
    return columns.length();
    ;
}
 
QVariant PeerTableModel::data(const QModelIndex& index, int role) const
{
    if (!index.isValid())
        return QVariant();
 
    CNodeCombinedStats* rec = static_cast<CNodeCombinedStats*>(index.internalPointer());
 
    if (role == Qt::DisplayRole) {
        switch(index.column()) {
        case NetNodeId:
            return rec->nodeStats.nodeid;
        case Address:
            return QString::fromStdString(rec->nodeStats.addrName);
        case Subversion:
            return QString::fromStdString(rec->nodeStats.cleanSubVer);
        case Ping:
            return GUIUtil::formatPingTime(rec->nodeStats.dPingTime);
        }
    } else if (role == Qt::TextAlignmentRole) {
        if (index.column() == Ping)
            return (int)(Qt::AlignRight | Qt::AlignVCenter);
    }
 
    return QVariant();
}
 
QVariant PeerTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal) {
        if (role == Qt::DisplayRole && section < columns.size()) {
            return columns[section];
        }
    }
    return QVariant();
}
 
Qt::ItemFlags PeerTableModel::flags(const QModelIndex& index) const
{
    if (!index.isValid())
        return Qt::NoItemFlags;
 
    Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
    return retval;
}
 
QModelIndex PeerTableModel::index(int row, int column, const QModelIndex& parent) const
{
    Q_UNUSED(parent);
    CNodeCombinedStats* data = priv->index(row);
 
    if (data) {
        return createIndex(row, column, data);
    } else {
        return QModelIndex();
    }
}
 
const CNodeCombinedStats* PeerTableModel::getNodeStats(int idx)
{
    return priv->index(idx);
}
 
void PeerTableModel::refresh()
{
    Q_EMIT layoutAboutToBeChanged();
    priv->refreshPeers();
    Q_EMIT layoutChanged();
}
 
int PeerTableModel::getRowByNodeId(NodeId nodeid)
{
    std::map<NodeId, int>::iterator it = priv->mapNodeRows.find(nodeid);
    if (it == priv->mapNodeRows.end())
        return -1;
 
    return it->second;
}
 
void PeerTableModel::sort(int column, Qt::SortOrder order)
{
    priv->sortColumn = column;
    priv->sortOrder = order;
    refresh();
}