myvtm/Framework/spshell/Widgets/performwidget.cpp

#include "performwidget.h"
#include "ui_performwidget.h"

#define COLUMN_NAME_INDEX   0
#define COLUMN_PID_INDEX    1
#define COLUMN_CPU_INDEX    2
#define COLUMN_MEM_INDEX    3
#define COLUMN_COMMAND_INDEX    4
#define COLUMN_FDS_INDEX    5
#define MAX_PERFORM_LIST_COLUMN 6

//RUSER      PID %CPU %MEM COMMAND         COMMAND
#define RAW_RUSER_INDEX   0
#define RAW_PID_INDEX    1
#define RAW_CPU_INDEX    2
#define RAW_MEM_INDEX    3
#define RAW_COMMAND_INDEX    4
#define RAW_FDS_INDEX    5

PerformWidget::PerformWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::PerformWidget)
{
    ui->setupUi(this);

    ui->performTableWidget->setColumnCount(MAX_PERFORM_LIST_COLUMN);
    QStringList header;
#ifdef WITH_QT
    header << "名称"  << "进程号" << "CPU[%]" << "内存[%]" << "命令" << "文件句柄数";
#else
    header << "Name"  << "PIC" << "CPU[%]" << "MEM[%]" << "CMD" << "Fds" ;
#endif

    ui->performTableWidget->setHorizontalHeaderLabels(header);

    ui->performTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    //ui->performTableWidget->horizontalHeader()->setSectionResizeMode(COLUMN_PID_INDEX, QHeaderView::ResizeToContents);
    //ui->performTableWidget->horizontalHeader()->setSectionResizeMode(COLUMN_CPU_INDEX, QHeaderView::ResizeToContents);
    //ui->performTableWidget->horizontalHeader()->setSectionResizeMode(COLUMN_MEM_INDEX, QHeaderView::ResizeToContents);
    ui->performTableWidget->resizeColumnToContents(0);

    ui->performTableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->performTableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->performTableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->performTableWidget->verticalHeader()->hide();
    ui->performTableWidget->horizontalHeader()->setStretchLastSection(true);
    ui->performTableWidget->horizontalHeader()->setVisible(true);
    ui->performTableWidget->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft | Qt::AlignVCenter);
    ui->performTableWidget->setStyleSheet("selection-background-color:#1E90FF;");
    ui->performTableWidget->setFrameShape(QFrame::NoFrame);

    connect(ui->performTableWidget->horizontalHeader(), SIGNAL(sectionClicked(int)), this, SLOT(sortByColumn(int)));

    cmd = CPU_SORT;
    process = new QProcess(this);
    pro = new QProcess(this);
    timer = new QTimer(this);
    timer->setInterval(3000);
    timer->setSingleShot(true);
    connect(timer,SIGNAL(timeout()),this,SLOT(GetPerformInfo()));
    GetPerformInfo();
}

int PerformWidget::GetProcessFds(int processID)
{
#ifdef Q_OS_WIN32
    return 0;
#else
    QProcess* proc = new QProcess();
    int result = GetProcessFdsImpl(proc, processID);
    delete proc;
    return result;
#endif
}

int PerformWidget::GetProcessFdsImpl(QProcess* proc, int processID)
{
    proc->start("/bin/bash");
    if (proc->waitForStarted(3000)) {
        QString cmd = QString(FD_CALCU_SPRINT_STR).arg(processID);
        qDebug() << __FUNCTION__ << cmd;
        proc->write(cmd.toLatin1());
        proc->closeWriteChannel();
        if (proc->waitForFinished(3000)) {
            QString result = proc->readAllStandardOutput();
            if (!result.isEmpty()) {
                bool ok = false;
                int res = result.toInt(&ok, 10);
                qDebug() << __FUNCTION__ << ": result=" << res;
                if (ok) return res;
                return -1;
            } else {
                qDebug() << __FUNCTION__ << ": empty";
            }
        } else {
            qDebug() << __FUNCTION__ << ":@1 " << proc->errorString();
        }
    } else {
        qDebug() << __FUNCTION__ << ":@2  " << proc->errorString();
    }
    return -1;
}

void PerformWidget::UpdateMemUsed()
{
    pro->start("free -m");
    if(pro->waitForStarted(2000))
    {
        if(pro->waitForFinished(1000))
        {
            QString result = pro->readAllStandardOutput();
            if(!result.isEmpty())
            {
                memused = 0;
                qint64 total, used;
                total = 0;
                used = 0;
                reg.setPattern("\\d+.+");
                QString tmp = reg.match(result).captured(0);
                QStringList list = tmp.split(QRegularExpression(" +"));
                result = list.at(0); //total
                tmp = list.at(5); //available
                total = result.toLongLong();
                used = tmp.toLongLong();
                memused = used * 1000 / total;
                memused = 1000 - memused;
                int m = memused % 10;
                memused /= 10;
                if (m >= 5) memused += 1;
            }
        }
    }
}

void PerformWidget::sortByColumn(int selColumn)
{
    //ui->performTableWidget->sortItems(selColumn, Qt::AscendingOrder);
    if (selColumn == COLUMN_CPU_INDEX || selColumn == COLUMN_MEM_INDEX) {
        if (selColumn == COLUMN_CPU_INDEX) {
            if (cmd == CPU_SORT)  return;
            cmd = CPU_SORT;
        } else if (selColumn == COLUMN_MEM_INDEX) {
            if (cmd == MEM_SORT)  return;
            cmd = MEM_SORT;
        }
        GetPerformInfo();
    }
}

bool PerformWidget::GetPerformInfo()
{
    timer->stop();

    ui->performTableWidget->clearContents();

    process->start("/bin/bash");
    if(process->waitForStarted(3000)) {
        process->write(cmd.toLatin1());
        process->closeWriteChannel();
        process->waitForFinished(3000);
        QString result = process->readAllStandardOutput();
        QRegularExpression reg;
        reg.setPattern(" +");
        result = result.replace(reg," ");
        QStringList elemList = result.split("\n");
        elemList.removeFirst();
        elemList.removeLast();
        ui->performTableWidget->setRowCount(elemList.length());
        for(int i=0;i< elemList.length();i++) {
            QString line = elemList.at(i);
            QStringList elems = line.split(" ");
            QString strPID = elems.at(RAW_PID_INDEX);
            bool root = false, related = false;
            for(int j=0; j<ui->performTableWidget->columnCount(); j++) {
                QTableWidgetItem* item = new QTableWidgetItem;
                item->setBackground((i % 2 != 0) ? QColor("#f5f5f5") : QColor("#ffffff"));
                if(j== COLUMN_NAME_INDEX) {
                    item->setWhatsThis(strPID);
                    line = elems.at(RAW_COMMAND_INDEX);
                    if (line.compare("spshell", Qt::CaseInsensitive) == 0 
                        || line.compare("sphost", Qt::CaseInsensitive) == 0
                        || line.compare("cefclient", Qt::CaseInsensitive) == 0
                        || line.compare("guardian", Qt::CaseInsensitive) == 0) {
                        related = true;
                        item->setForeground(QBrush(Qt::red));

                        if (line.compare("sphost", Qt::CaseInsensitive) == 0 && elems.count() > 7 && elems.at(7).startsWith("mod_")) {
                            line = elems.at(7);
                        }
                    }

                    item->setToolTip(line);
                    item->setText(line);
                }
                else if (j == COLUMN_PID_INDEX) {
                    item->setTextAlignment(Qt::AlignHCenter);
                    item->setText(elems.at(RAW_PID_INDEX));
                }
                else if (j == COLUMN_CPU_INDEX) {
                    item->setTextAlignment(Qt::AlignHCenter);
                    item->setText(elems.at(RAW_CPU_INDEX));
                }
                else if (j == COLUMN_MEM_INDEX) {
                    item->setTextAlignment(Qt::AlignHCenter);
                    item->setText(elems.at(RAW_MEM_INDEX));
                }
                else if(j== COLUMN_COMMAND_INDEX)
                {
                    line = elems.mid(5).join(" ");
                    item->setText(line);
                    item->setToolTip(line);
                } else if(j == COLUMN_FDS_INDEX) {
                    if (related) {
                        int fds = GetProcessFdsImpl(pro, strPID.toInt());
                        item->setText(QString::number(fds));
                    } else {
                        item->setText("NA");
                    }

                }
                ui->performTableWidget->setItem(i, j, item);
            }
        }
    }

    timer->start();

    return true;
}

PerformWidget::~PerformWidget()
{
    delete ui;
}

bool PerformWidget::pidselected(const QString &pid)
{
    QString sel;
    for(int i=0;i<selected.length();i++)
    {
        sel=selected.at(i);
        if(pid==sel) {
            listupdate2freshselected.append(sel);
            return true;
        }
    }
    return false;
}