inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/client/inspectorj.cpp

Go to the documentation of this file.

/***************************************************************************
*   inspectorJ - java profiler                                            *
*   Copyright (C) 2006 by James May                                       *
*                                                                         *
*   This program 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 2 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, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/

#include "inspectorj/client/inspectorj.h"
#include <iostream>
        
using namespace inspectorj::jdwp;
using namespace inspectorj::toolset;
using inspectorj::model::BytecodeHighlighter;
using inspectorj::toolset::ProfileToolSet;
        
InspectorJ::InspectorJ(QWidget *parent, Qt::WindowFlags flags)
    : QMainWindow(parent, flags), profile(0), REFERENCE_TAB(0), BYTECODE_TAB(1)
{
    setupUi(this);
    
    connectionManager = new ConnectionManager(this, profiles, javaAppProcess);
    classToolSet = new ClassToolSet(*connectionManager, &profile);
    loadSettings();
    initWindow();
    createActions();
    createMenus();

    setupConnections();
    
    QFont currentFont = font();
    QList<QWidget *> widgets = this->findChildren<QWidget *>("");
    for (int i = 0; i < widgets.size(); i++) {
        QWidget *widget = widgets[i];
        widget->setFont(currentFont);
    }
}

void InspectorJ::initWindow()
{
    setWindowTitle("inspectorJ");
    setWindowIcon(QIcon(":/images/ij-16.png"));
    ctbFilterGroupBox->setVisible(false);
    allClassesBtn->setEnabled(false);
    bytecodeBtn->setEnabled(false);
    classTreeView->setAutoScroll(true);
    classTreeDockWidget->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);   

    connectedStateBtn = new QToolButton(this);
    connectedStateBtn->setIcon(QIcon(":/images/redled.png"));
    connectedStateBtn->setMaximumSize(QSize(16,16));
    connectedStateBtn->setToolTip("Disconnected");
    this->statusbar->addPermanentWidget(dynamic_cast<QWidget*>(connectedStateBtn)); 
      
    QFont codeFont;
    codeFont.setFamily("Monospace");
    codeFont.setFixedPitch(true);
    bytecodeTextEdit->setFont(codeFont);
    
    bytecodeHighlighter = new BytecodeHighlighter(bytecodeTextEdit->document());
    bytecodeGroupBox->setMaximumHeight(bytecodeGroupBox->sizeHint().height());
}

void InspectorJ::setupConnections()
{
    connect(allClassesBtn, SIGNAL(clicked()), classToolSet, SLOT(getAllLoadedClasses()));    
    connect(classToolSet, SIGNAL(tableModelReady()), this, SLOT(updateClassTable()));
    connect(classToolSet, SIGNAL(treeModelReady()), this, SLOT(updateClassTree()));
    connect(disconnectAction, SIGNAL (triggered()), connectionManager, SLOT (closeConnection()));
    connect(stopJavaAction, SIGNAL (triggered()), connectionManager, SLOT (stopJavaApp()));
    connect(fontAction, SIGNAL(triggered()), this, SLOT(showFontDlg()));
    connect(exitAction, SIGNAL(triggered()), this, SLOT(close()));
    connect(profileDirAction, SIGNAL(triggered()), this, SLOT (setProfileDirectory()));
    connect(connectedStateBtn, SIGNAL (clicked()), this, SLOT (getJvmInfo()));
    connect(jvmInfoResponse, SIGNAL (triggered(JDWPPacket&)), this, SLOT (showJvmInfo(JDWPPacket&)));
    connect(newProfileAction, SIGNAL(triggered()), this, SLOT(showSessionDlg()));
    connect(connectionManager, SIGNAL(connected(bool, QString&)), this, SLOT(connected(bool,QString&)));
    connect(ctbRemoveFilterBtn, SIGNAL(clicked()), this, SLOT(removeClassFilter()));
    connect(ctbAddFilterBtn, SIGNAL(clicked()), this, SLOT(addClassFilter()));
    connect(classTableView, SIGNAL(clicked(const QModelIndex&)), classToolSet, SLOT(getClassDetails(const QModelIndex&)));
    connect(bytecodeBtn, SIGNAL(clicked()), this, SLOT(disassembleBytecodes()));
    connect(classTableView, SIGNAL(clicked(const QModelIndex&)), this, SLOT(updateBytecodeBtn()));
    connect(classToolSet, SIGNAL(bytecodesReady()), this, SLOT(updateBytecodeTextEdit()));
    connect(&javaAppProcess, SIGNAL(error(QProcess::ProcessError)), this, SLOT (javaAppErr(QProcess::ProcessError)));
    connect(&javaAppProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT (javaAppFinished(int, QProcess::ExitStatus)));
    connect(&javaAppProcess, SIGNAL(readyReadStandardError()), this, SLOT (javaAppStdErr()));
    connect(&javaAppProcess, SIGNAL(readyReadStandardOutput()), this, SLOT (javaAppStdOut()));     
    connect(&javaAppProcess, SIGNAL(started()), this, SLOT (javaAppStarted()));           
}

void InspectorJ::connected(bool attached, QString &msg)
{
    disconnectAction->setEnabled(attached);
    allClassesBtn->setEnabled(attached);
    updateBytecodeBtn();
    updateClassToolBox(attached);
    this->statusbar->showMessage(msg);
    if (attached) {
        connectedStateBtn->setIcon(QIcon(":/images/greenled.png"));
        connectedStateBtn->setToolTip("Connected");
        QList<QAction*> actions = editProfileMenuItem->actions();
        for (int i = 0; i < actions.size(); ++i) {
            if (actions[i]->data() == profile->getName()) {
                actions[i]->setEnabled(false);
            }                
        }
        allClassesBtn->click();
    } else {
        connectedStateBtn->setIcon(QIcon(":/images/redled.png"));
        connectedStateBtn->setToolTip("Disconnected");
        QList<QAction*> actions = editProfileMenuItem->actions();
        for (int i = 0; i < actions.size(); ++i) {
            actions[i]->setEnabled(true);             
        }        
        profile = 0;
    }
}

void InspectorJ::updateClassToolBox(bool attached)
{
    ctbFilterGroupBox->setVisible(attached);
    if (attached) {
        ctbClassFilterList->clear();
        QStringList filters = profile->getClassFilters();
        QStringListIterator iter(filters);
        while (iter.hasNext()) {
            ctbClassFilterList->addItem(iter.next());
        }        
    }
}

void InspectorJ::addClassFilter()
{
    if (connectionManager->isAttached()) {
        if (! ctbFilterEdit->text().isEmpty()) {
            profile->addFilter(ctbFilterEdit->text());
            ctbClassFilterList->addItem(ctbFilterEdit->text());
            ctbFilterEdit->clear();
        }
    }
}

void InspectorJ::removeClassFilter()
{
    if (connectionManager->isAttached()) {
        QList<QListWidgetItem *> itemList = ctbClassFilterList->selectedItems(); 
        QList<QListWidgetItem *>::iterator iter;
        for (iter = itemList.begin(); iter != itemList.end(); ++iter) {        
            QListWidgetItem *item = ctbClassFilterList->takeItem(ctbClassFilterList->row(*iter));
            profile->removeFilter(item->text());
        }
    }    
}


void InspectorJ::showSessionDlg()
{
    if (profileDir.isEmpty()) {
        profileDir = browseProfileDirectory();
        if (profileDir.isEmpty()) {
            return;
        } 
    }
    
    QAction *action = qobject_cast<QAction *>(sender());
    if (action) {    
        SessionProfileDialog dlg(profiles, action->data().toString());
        dlg.setFont(font());
        dlg.setProfileDir(profileDir);
        dlg.exec();
        updateSessionsMenu();
        updateClassToolBox(connectionManager->isAttached());
    }
}

void InspectorJ::showFontDlg()
{
    bool ok;
    QFont currentFont = font();
    QFont font = QFontDialog::getFont(&ok, currentFont, this );
    if ( ok ) {
        setFont(font);
        QList<QWidget *> widgets = this->findChildren<QWidget *>("");
        for (int i = 0; i < widgets.size(); i++) {
            QWidget *widget = widgets[i];
            widget->setFont(font);
        }
        QFont treeFont(classTreeView->font());
        treeFont.setPointSize(font.pointSize());
        classTreeView->setFont(treeFont);
    }
}

void InspectorJ::showJvmInfo(JDWPPacket& reply)
{   
    if(ClientPacketHandler::handleJDWPError(reply)) {
        return;
     } else {
         QString msg;
         reply >> msg;
         QString title = "JVM Information";
         QMessageBox::information( this, title, msg,
                               QMessageBox::Ok | QMessageBox::Default);
     }
}
    
void InspectorJ::getJvmInfo()
{
    if(connectionManager->isAttached()) {
        JDWPCommand *cmd = JDWPCommand::newCommand(VM_CMD_VERSION);    
        connectionManager->sendRequest(cmd,  jvmInfoResponse);
    }
}

void InspectorJ::disassembleBytecodes()
{
    bytecodeBtn->setEnabled(false);
    bytecodeTextEdit->document()->clear();
    bytecodeTextEdit->document()->setPlainText(
            "inspectorJ: Getting bytecodes. Please wait...");
    classToolSet->disassembleBytecodes(
            classTableView->selectionModel()->currentIndex(),
            bytecode_cb_disassemble->isChecked(),
            bytecode_cb_lineNumber->isChecked(),
            bytecode_cb_private->isChecked(),
            bytecode_cb_internal->isChecked(),
            bytecode_cb_verbose->isChecked());
}

void InspectorJ::updateBytecodeTextEdit()
{
    classToolSet->prepareBytecodeOutput(bytecodeTextEdit->document());
    updateBytecodeBtn();
}

void InspectorJ::updateBytecodeBtn()
{
    if (!connectionManager->isAttached()) {
        bytecodeBtn->setEnabled(false);
        return;
    }
    bool enabled = false;
    QItemSelectionModel *selectionModel;
    selectionModel = classTableView->selectionModel();
    if (selectionModel) {
        enabled = selectionModel->hasSelection();
    }
    bytecodeBtn->setEnabled(enabled);
}
    

void InspectorJ::loadSettings()
{
    // Restore geometry
    QSettings settings("inspectorJ", "inspectorJ");
    QRect rect = settings.value("geometry", QRect(0,0,800,600)).toRect();
    move(rect.topLeft());
    resize(rect.size());
     
    consoleTabSplitter->restoreState(settings.value("consoleTabSplitterSizes").toByteArray());
    splitter1->restoreState(settings.value("splitter1Sizes").toByteArray());
    splitter2->restoreState(settings.value("splitter2Sizes").toByteArray());
    splitter3->restoreState(settings.value("splitter3Sizes").toByteArray());
    splitter4->restoreState(settings.value("splitter4Sizes").toByteArray());
    splitter5->restoreState(settings.value("splitter5Sizes").toByteArray());    
     
    // Restore profile directory
    profileDir = settings.value("profileDirectory").toString();
    
    loadProfiles();   
    
    // Restore font settings
    QFont font = settings.value("font", QFont("Sans Serif", 8)).value<QFont>();
    setFont(font);
}

void InspectorJ::saveSettings()
{
    // Save geometry
    QSettings settings("inspectorJ", "inspectorJ");
    settings.setValue("geometry", geometry());
       
    settings.setValue("consoleTabSplitterSizes", consoleTabSplitter->saveState());
    settings.setValue("splitter1Sizes", splitter1->saveState());
    settings.setValue("splitter2Sizes", splitter2->saveState());
    settings.setValue("splitter3Sizes", splitter3->saveState());
    settings.setValue("splitter4Sizes", splitter4->saveState());
    settings.setValue("splitter5Sizes", splitter5->saveState());
          
    settings.setValue("profileDirectory", profileDir);
    
    // Save font preference
    QFont currentFont = font();
    settings.setValue("font", currentFont);
}

void InspectorJ::loadProfiles()
{
        // If profileDir is not set, try to create a default one
    if (profileDir.isEmpty()) {
        QString tmp = QDir::homePath().append(QDir::separator());
        tmp.append("inspectorj").append(QDir::separator());
        tmp.append("profiles"); 
        
        QDir tmpDir(tmp);
        if (tmpDir.exists() || tmpDir.mkpath(tmpDir.path())) {
            profileDir = tmp;
        }
    }

    // load profiles stored on disk...
    QDir dir(profileDir);
    if (dir.exists()) {
        QStringList filters;
        filters << "*.xml";
        QStringList files = dir.entryList(filters);
        for (int i = 0; i < files.size(); ++i) {
            SessionProfile profile;
            if (ProfileToolSet::loadProfile(profile, dir.absoluteFilePath(files.at(i)))) {
                profiles[profile.getName()] = profile;            
            }
        }       
    } 
}

void InspectorJ::setProfileDirectory()
{
    QString newDir = browseProfileDirectory();
    if (profileDir != newDir) {
        profileDir = newDir;
        profiles.clear();
        loadProfiles();
        updateSessionsMenu();
    }    
}

QString InspectorJ::browseProfileDirectory()
{
    QFileDialog fileDialog(this, QString("Select a profile directory"), profileDir);
    fileDialog.setFileMode(QFileDialog::DirectoryOnly);
    QStringList fileNames;
    if (fileDialog.exec()) {
        fileNames = fileDialog.selectedFiles();
        return fileNames.at(0);
    } 
    return QString("");
}

void InspectorJ::closeEvent(QCloseEvent *event)
{
    QString msg = "Are you sure you want to exit inspectorJ ?";
    int result = QMessageBox::information(this, 
                        " inspectorJ - Exit ?", msg,
                        QMessageBox::Yes | QMessageBox::Default, 
                        QMessageBox::No);
    
    if (result == QMessageBox::Yes) {
        connectionManager->setExiting(true);
        connectionManager->closeConnection();
        
        // If we've started a java or other application process, try to                                             
        // bring it down gracefully before exiting.
        QProcess::ProcessState state = javaAppProcess.state();
        if (state == QProcess::Starting || state == QProcess::Running) {
            QString msg("Please wait while the launched process is terminated.");        
            
            javaAppProcess.kill();
            javaAppProcess.waitForFinished();
        }
            
        saveSettings();
        event->accept(); 
    } else {
        event->ignore();
    }
}

void InspectorJ::createActions()
{
    stopJavaAction = new QAction("&Stop Java App", this);
    stopJavaAction->setEnabled(false);
    disconnectAction = new QAction("&Disconnect", this);
    disconnectAction->setEnabled(false);
    jvmInfoResponse = new JDWPAction(this);
}

void InspectorJ::createMenus()
{
    // Connections menu
    attachProfileMenuItem = menuSessions->addMenu("&Attach");
    attachProfileMenuItem->setEnabled(false);
    launchProfileMenuItem = menuSessions->addMenu("&Launch");
    launchProfileMenuItem->setEnabled(false);
    editProfileMenuItem = menuSessions->addMenu("&Edit");
    editProfileMenuItem->setEnabled(false);  
    menuSessions->addSeparator();  
    menuSessions->addAction(disconnectAction);
    menuSessions->addAction(stopJavaAction);
    updateSessionsMenu();
}

void InspectorJ::updateSessionsMenu()
{
    QMapIterator<QString, SessionProfile> iter(profiles);
    
    // clear the SessionProfile menu items
    editProfileMenuItem->setEnabled(iter.hasNext());
    editProfileMenuItem->clear();
    attachProfileMenuItem->setEnabled(false);
    attachProfileMenuItem->clear();
    launchProfileMenuItem->setEnabled(false);
    launchProfileMenuItem->clear();
     
    // rebuild the menu items
    while (iter.hasNext()) {
        iter.next();
        SessionProfile sProfile = iter.value();

        if (sProfile.isExternalLaunch()) {
            attachProfileMenuItem->setEnabled(true);
            QAction *startAction = new QAction(iter.key(), this);
            QStringList actionData;
            ijConnection conn = sProfile.getConnection();
            actionData << sProfile.getName() << conn.host << conn.port;
            startAction->setData(actionData);
            attachProfileMenuItem->addAction(startAction);
                        connect(startAction, SIGNAL(triggered()), this, SLOT(setCurrentProfile()));
            connect(startAction, SIGNAL(triggered()), connectionManager, SLOT(attachToServer()));               
        } else {
            launchProfileMenuItem->setEnabled(true);
            QAction *launchAction = new QAction(iter.key(), this);
            QStringList actionData;
            actionData << sProfile.getName() << profileDir;
            launchAction->setData(actionData);
            launchProfileMenuItem->addAction(launchAction);
                        connect(launchAction, SIGNAL(triggered()), this, SLOT(setCurrentProfile()));
            connect(launchAction, SIGNAL(triggered()), connectionManager, SLOT(launchJavaApp()));               
        } 
        
        QAction *editAction = new QAction(iter.key(), this);
        editAction->setData(iter.key());
        editProfileMenuItem->addAction(editAction);
        connect(editAction, SIGNAL(triggered()), this, SLOT(showSessionDlg()));
    }
}


void InspectorJ::setCurrentProfile()
{
    QAction *action = qobject_cast<QAction *>(sender());
    if (action) {
        QStringList actionData = action->data().toStringList();
        QString profileName;
        profileName = actionData[0];
        profile = &(profiles[profileName]);
    }
}
    
void InspectorJ::updateClassTree()
{
    this->classTreeView->reset();
    ClassTreeModel *classTreeModel = classToolSet->getClassTreeModel();
    classTreeModel->initModel();
    this->classTreeView->setModel(classTreeModel);
    this->classTreeView->expandAll();   
    int columnCount = classTreeModel->columnCount();
    for (int i = 0; i < columnCount; i++) {
        this->classTreeView->resizeColumnToContents(i); 
    }    
}    

void InspectorJ::updateClassTable()
{
    ClassTableModel *classTableModel = classToolSet->getClassTableModel();
    this->classTableView->setModel(classTableModel);
    this->classTableView->reset();
    classTableView->setColumnWidth(0,classTableView->viewport()->width());
    classTableView->resizeRowsToContents();
    QString totalClassesNum;
    QString filteredClassesNum;
    totalClassesNum.setNum(classTableModel->getTotalClassesLoaded());
    filteredClassesNum.setNum(classTableModel->getFilteredClassesLoaded());
    totalClassesLoadedVal->setText(totalClassesNum);
    filteredClassesLoadedVal->setText(filteredClassesNum);
}

void InspectorJ::javaAppErr(QProcess::ProcessError error)
{
    QString javaOutput;
    if (error == QProcess::FailedToStart) {
        javaOutput.append("java executable could not be started.");
        javaOutput.append("Make sure the profile's jre/jdk home is correct");
    } else {
        javaOutput.append("An unknown error has occurred.");
    }
    
    consoleTextEdit->append(javaOutput);
}

void InspectorJ::javaAppFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    stopJavaAction->setEnabled(false);
    QString javaOutput;
    javaOutput = QString::fromLocal8Bit(javaAppProcess.readAllStandardOutput());
    javaOutput.append("\n");
    
    if (exitStatus == QProcess::CrashExit) {
        javaOutput.append("The application exited unexpectedly.");
    } else if (exitCode != 0) {
        javaOutput.append("The application exited with code: ");
        javaOutput.append(QString::number(exitCode));        
    }
    consoleTextEdit->append(javaOutput);
}

void InspectorJ::javaAppStdErr()
{
    if (javaAppProcess.state() == QProcess::NotRunning) {
        stopJavaAction->setEnabled(false);
    }
    
    statusbar->clearMessage();
    QString msg = QString::fromLocal8Bit(javaAppProcess.
            readAllStandardError());
    if (!msg.isEmpty()) {
        consoleTextEdit->append(cleanConsoleText(msg));
    }
}

void InspectorJ::javaAppStdOut()
{
    QString msg = QString::fromLocal8Bit(javaAppProcess.
            readAllStandardOutput());
    if (!msg.isEmpty()) {
        consoleTextEdit->append(cleanConsoleText(msg));
    }
}

void InspectorJ::javaAppStarted()
{
    stopJavaAction->setEnabled(true);
    if (connectionManager->startAttachTimer(2000, profile->getConnection())) {
        QString msg("Attaching to ");
        msg.append(profile->getName());
        msg.append(" profile launched process. Please wait...");
        statusbar->showMessage(msg);
    }
}

QString& InspectorJ::cleanConsoleText(QString& msg)
{
    int len = msg.length();
    if (len > 0 && msg[len-1] == QChar('\n')) {
        msg.remove(len-1, 1);
    }
    len = msg.length();
    if (len > 0 && msg[len-1] == QChar('\r')) {
        msg.remove(len-1, 1);
    }
    return msg;   
}

---