ostinato/client/portstatsmodel.cpp

/*
Copyright (C) 2010 Srivats P.

This file is part of "Ostinato"

This is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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/>
*/

#include "portstatsmodel.h"
#include "portgrouplist.h"

#include <QApplication>
#include <QPainter>
#include <QPalette>
#include <QPixmapCache>
#include <QTimer>

enum {
    // XXX: The byte stats don't include FCS so include it in the overhead
    kPerPacketByteOverhead = 24 // 1(SFD)+7(Preamble)+12(IPG)+4(FCS)
};

PortStatsModel::PortStatsModel(PortGroupList *p, QObject *parent)
    : QAbstractTableModel(parent) 
{
    pgl = p;

    timer = new QTimer();
    connect(timer, SIGNAL(timeout()), this, SLOT(updateStats()));
    timer->start(1000);
}

PortStatsModel::~PortStatsModel()
{
    timer->stop();
    delete timer;
}

int PortStatsModel::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;

    if (numPorts.isEmpty())
        return 0;

    if (numPorts.last() == 0)
        return 0;

    return (int) e_STAT_MAX;    
}

int PortStatsModel::columnCount(const QModelIndex &parent ) const
{
    if (parent.isValid())
        return 0;
    else
        if (numPorts.isEmpty())
            return 0;
        else
            return numPorts.last();
}

void PortStatsModel::getDomainIndexes(const QModelIndex &index,
        uint &portGroupIdx, uint &portIdx) const
{
    int portNum;

    // TODO(LOW): Optimize using binary search: see qLowerBound()
    portNum = index.column() + 1;
    for (portGroupIdx = 0; portGroupIdx < (uint) numPorts.size(); portGroupIdx++)
        if (portNum <= numPorts.at(portGroupIdx))
            break;

    if (portGroupIdx)
    {
        if (numPorts.at(portGroupIdx -1))
            portIdx = (portNum - 1) - numPorts.at(portGroupIdx - 1); 
        else
            portIdx = portNum - 1; 
    }
    else
        portIdx = portNum - 1; 

    //qDebug("PSM: %d - %d, %d", index.column(), portGroupIdx, portIdx);
}

QVariant PortStatsModel::data(const QModelIndex &index, int role) const
{
    // Check for a valid index
    if (!index.isValid())
        return QVariant();

    // Check for row/column limits
    int row = index.row();
    if (row >= e_STAT_MAX)
        return QVariant();

    if (numPorts.isEmpty())
        return QVariant();

    if (index.column() >= (numPorts.last()))
        return QVariant();

    if (role == Qt::TextAlignmentRole)
    {
        if (row >= e_STATISTICS_START && row <= e_STATISTICS_END)
            return Qt::AlignRight;      // right-align numbers
        else
            return Qt::AlignHCenter;    // center-align everything else
    }

    uint pgidx, pidx;
    getDomainIndexes(index, pgidx, pidx);

    OstProto::PortStats stats = pgl->mPortGroups.at(pgidx)
                                        ->mPorts[pidx]->getStats();
    // Check role
    if (role == Qt::DisplayRole)
    {
        switch(row)
        {
            // Info
            case e_INFO_USER:
                return pgl->mPortGroups.at(pgidx)->mPorts[pidx]->userName();

            // States
            case e_COMBO_STATE:
                return QString("Link %1%2%3")
                    .arg(LinkStateName.at(stats.state().link_state()))
                    .arg(stats.state().is_transmit_on() ? ";Tx On" : "")
                    .arg(stats.state().is_capture_on() ? ";Cap On" : "");

            // Statistics
            case e_STAT_FRAMES_RCVD:
                return QString("%L1").arg(quint64(stats.rx_pkts()));

            case e_STAT_FRAMES_SENT:
                return QString("%L1").arg(quint64(stats.tx_pkts()));

            case e_STAT_FRAME_SEND_RATE:
                return QString("%L1").arg(quint64(stats.tx_pps()));

            case e_STAT_FRAME_RECV_RATE:
                return QString("%L1").arg(quint64(stats.rx_pps()));

            case e_STAT_BYTES_RCVD:
                return QString("%L1").arg(quint64(stats.rx_bytes()));

            case e_STAT_BYTES_SENT:
                return QString("%L1").arg(quint64(stats.tx_bytes()));

#if 0
            case e_STAT_BYTE_SEND_RATE:
                return QString("%L1").arg(quint64(stats.tx_bps()));

            case e_STAT_BYTE_RECV_RATE:
                return QString("%L1").arg(quint64(stats.rx_bps()));
#endif

            case e_STAT_BIT_SEND_RATE:
                return QString("%L1").arg(quint64(
                            stats.tx_bps()
                                + stats.tx_pps()*kPerPacketByteOverhead)*8);

            case e_STAT_BIT_RECV_RATE:
                return QString("%L1").arg(quint64(
                            stats.rx_bps()
                                + stats.rx_pps()*kPerPacketByteOverhead)*8);

#if 0
            case e_STAT_FRAMES_RCVD_NIC:
                return stats.rx_pkts_nic();

            case e_STAT_FRAMES_SENT_NIC:
                return stats.tx_pkts_nic();

            case e_STAT_BYTES_RCVD_NIC:
                return stats.rx_bytes_nic();

            case e_STAT_BYTES_SENT_NIC:
                return stats.tx_bytes_nic();
#endif

            case e_STAT_RX_DROPS:
                return QString("%L1").arg(quint64(stats.rx_drops()));
            case e_STAT_RX_ERRORS:
                return QString("%L1").arg(quint64(stats.rx_errors()));
            case e_STAT_RX_FIFO_ERRORS:
                return QString("%L1").arg(quint64(stats.rx_fifo_errors()));
            case e_STAT_RX_FRAME_ERRORS:
                return QString("%L1").arg(quint64(stats.rx_frame_errors()));

            default:
                qWarning("%s: Unhandled stats id %d\n", __FUNCTION__,
                        index.row());
                return 0;
        }
    }
    else if (role == Qt::DecorationRole)
    {
        if (row == e_COMBO_STATE)
            return statusIcons(
                        stats.state().link_state(),
                        stats.state().is_transmit_on(),
                        stats.state().is_capture_on());
        else
            return QVariant();
    }
    else if (role == Qt::ToolTipRole)
    {
        if (row == e_COMBO_STATE) {
            QString linkIcon;
            switch (stats.state().link_state()) {
                case OstProto::LinkStateUp:
                    linkIcon = ":/icons/bullet_green.png";
                    break;
                case OstProto::LinkStateDown:
                    linkIcon = ":/icons/bullet_red.png";
                    break;
                case OstProto::LinkStateUnknown:
                    linkIcon = ":/icons/bullet_white.png";
                    break;
            }
            // FIXME: Ideally, the text should be vertically centered wrt icon
            // but style='vertical-align:middle for the img tag doesn't work
            QString tooltip = QString("<img src='%1'/> Link %2")
                                .arg(linkIcon)
                                .arg(LinkStateName.at(
                                            stats.state().link_state()));
            if (stats.state().is_transmit_on())
                tooltip.prepend("<img src=':/icons/transmit_on.png'/>"
                                " Transmit On<br/>");
            if (stats.state().is_capture_on())
                tooltip.append("<br/><img src=':/icons/sound_none.png'/>"
                               " Capture On");
            return tooltip;
        }
        else
            return QVariant();
    }
    else
        return QVariant();

}

QVariant PortStatsModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role == Qt::ToolTipRole)
    {
        if (orientation == Qt::Horizontal)
        {
            QString notes;
            uint portGroupIdx, portIdx;

            if (numPorts.isEmpty() || section >= numPorts.last())
                return QVariant();
            getDomainIndexes(index(0, section), portGroupIdx, portIdx);    
            notes = pgl->mPortGroups.at(portGroupIdx)->mPorts[portIdx]->notes();
            if (!notes.isEmpty())
                return notes;
            else
                return QVariant();
        }
        else
            return QVariant();
    }

    if ((role == Qt::BackgroundRole) && (orientation == Qt::Vertical)
        && qApp->styleSheet().isEmpty())
    {
        QPalette palette = QApplication::palette();
        return section & 0x1 ?
                    palette.alternateBase() : palette.base();
    }

    if (role != Qt::DisplayRole)
        return QVariant();

    if (orientation == Qt::Horizontal)
    {
        uint portGroupIdx, portIdx;
        QString portName;

        if (numPorts.isEmpty() || section >= numPorts.last())
            return QVariant();

        getDomainIndexes(index(0, section), portGroupIdx, portIdx);    

        PortGroup *portGroup = pgl->mPortGroups.at(portGroupIdx);
        Port *port = portGroup->mPorts.at(portIdx);

        portName = QString("Port %1-%2")
            .arg(portGroup->id())
            .arg(port->id());
        if (portGroupIdx < (uint) pgl->mPortGroups.size() 
            && portIdx < (uint) portGroup->mPorts.size())
        {
            if (!port->notes().isEmpty())
                portName += " *";
            portName += "\n";
            portName += port->userDescription().isEmpty() ?
                port->userAlias() : port->userDescription();
        }
        return portName;
    }
    else
        return PortStatName.at(section);
}

Qt::DropActions PortStatsModel::supportedDropActions() const
{
    return Qt::IgnoreAction; // read-only model, doesn't accept any data
}

void PortStatsModel::portListFromIndex(QModelIndexList indices, 
        QList<PortGroupAndPortList> &portList)
{
    int i, j;
    QModelIndexList        selectedCols(indices);

    portList.clear();

    //selectedCols = indices.selectedColumns();
    for (i = 0; i < selectedCols.size(); i++)
    {
        uint portGroupIdx, portIdx;

        getDomainIndexes(selectedCols.at(i), portGroupIdx, portIdx);    
        for (j = 0; j < portList.size(); j++)
        {
            if (portList[j].portGroupId == portGroupIdx)
                break;
        }

        if (j >= portList.size())
        {
            // PortGroup Not found
            PortGroupAndPortList    p;

            p.portGroupId = portGroupIdx;
            p.portList.append(portIdx);

            portList.append(p);
        }
        else
        {
            // PortGroup found

            portList[j].portList.append(portIdx);
        }
    }
}

//
// Slots
//
void PortStatsModel::when_portListChanged()
{
    int i, count = 0;

    beginResetModel();

    // recalc numPorts
    while (numPorts.size())
        numPorts.removeFirst();

    for (i = 0; i < pgl->mPortGroups.size(); i++)
    {
        count += pgl->mPortGroups.at(i)->numPorts();
        numPorts.append(count);
    }

    endResetModel();
}

void PortStatsModel::when_portGroupDataChanged(int /*portGroupId*/, int /*portId*/)
{
    if (!columnCount())
        return;

    // Port (user) description may have changed - update column headers
    // TODO: update only the changed ports, not all
    emit headerDataChanged(Qt::Horizontal, 0, columnCount()-1);
}

// FIXME: unused? if used, the index calculation row/column needs to be swapped
#if 0
void PortStatsModel::on_portStatsUpdate(int port, void* /*stats*/)
{
    QModelIndex topLeft = index(port, 0, QModelIndex());
    QModelIndex bottomRight = index(port, e_STAT_MAX, QModelIndex());

    emit dataChanged(topLeft, bottomRight);
}
#endif

void PortStatsModel::updateStats()
{
    // Request each portgroup to fetch updated stats - the port group
    // raises a signal once updated stats are available
    for (int i = 0; i < pgl->mPortGroups.size(); i++)
        pgl->mPortGroups[i]->getPortStats();
}

void PortStatsModel::when_portGroup_stats_update(quint32 /*portGroupId*/)
{
    // FIXME(MED): update only the changed ports, not all

    QModelIndex topLeft = index(0, 0, QModelIndex());
    QModelIndex bottomRight = index(rowCount()-1, columnCount()-1, QModelIndex());

    emit dataChanged(topLeft, bottomRight);
}

QPixmap PortStatsModel::statusIcons(
        int linkState, bool transmit, bool capture) const
{
    QPixmap pixmap;
    QString key = QString("$ost:statusList:%1:%2:%3")
                    .arg(linkState).arg(transmit).arg(capture);

    if (QPixmapCache::find(key, pixmap))
        return pixmap;

    static int sz = QPixmap(":/icons/transmit_on.png").width();

    // Assume all icons are of same size and are square
    QPixmap blank(sz, sz);
    blank.fill(Qt::transparent);

    pixmap = QPixmap(sz*3, sz);
    pixmap.fill(Qt::transparent);

    QPainter painter(&pixmap);

    painter.drawPixmap(0, 0,
            transmit ? QPixmap(":/icons/transmit_on.png") : blank);

    switch (linkState) {
    case OstProto::LinkStateUp:
        painter.drawPixmap(sz, 0, QPixmap(":/icons/bullet_green.png"));
        break;
    case OstProto::LinkStateDown:
        painter.drawPixmap(sz, 0, QPixmap(":/icons/bullet_red.png"));
        break;
    case OstProto::LinkStateUnknown:
        painter.drawPixmap(sz, 0, QPixmap(":/icons/bullet_white.png"));
        break;
    default:
        painter.drawPixmap(sz, 0, blank);
    }

    painter.drawPixmap(sz*2, 0,
            capture ? QPixmap(":/icons/sound_none.png") : blank);


    QPixmapCache::insert(key, pixmap);
    return pixmap;
}