inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/client/connectionmanager.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by $AUTHOR$
 *                                                                         *
 *   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/connectionmanager.h"
        
using namespace inspectorj::client;
using namespace inspectorj::jdwp;        
 
ConnectionManager::ConnectionManager(QObject *prnt, QMap<QString, SessionProfile> &profiles, QProcess &process)
    : parent(prnt), profiles(profiles), javaAppProcess(process), handler(tcpSocket), attached(false)
{
    this->setParent(parent);
    connect(&tcpSocket, SIGNAL(connected()), this, SLOT(sendHandshake()));
    connect(&tcpSocket, SIGNAL(delayedCloseFinished()),
             this, SLOT(connectionClosedByServer()));
    connect(&tcpSocket, SIGNAL(readyRead()), this, SLOT(readPacket()));
    connect(&tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
             this, SLOT(error(QAbstractSocket::SocketError)));    
}

bool ConnectionManager::isAttached()
{
    return attached;
}

void ConnectionManager::sendRequest(JDWPCommand *cmd, QList<JDWPAction*> &actions) {
    handler.sendJDWPCommand(cmd, actions);
}


void ConnectionManager::sendRequest(JDWPCommand *cmd, JDWPAction* action) {
    QList<JDWPAction*> actions;
    actions << action;
    sendRequest(cmd, actions);
}


void ConnectionManager::readPacket()
{
    if (attached)
    {
        handler.readJDWPPacket();
    }
    else
    {
        receiveHandshake();
    }
}

bool ConnectionManager::okToLaunch()
{
    QProcess::ProcessState state = javaAppProcess.state();
    if (state == QProcess::Starting || state == QProcess::Running) {
        QString peerName = tcpSocket.peerName();
        QString peerPort;
        peerPort.setNum(tcpSocket.peerPort());
        QString msg = "You are currently connected to a running process on ";
        msg.append(peerName).append(":").append(peerPort);
        msg.append("\nDo you want to disconnect and terminate this process?");

        int result = QMessageBox::information(dynamic_cast<QWidget*>(parent), "inspectorJ Launch", msg,
                QMessageBox::Yes | QMessageBox::Default, QMessageBox::No);
        if (result == QMessageBox::Yes) {
            closeConnection();
            javaAppProcess.terminate();
            while (javaAppProcess.state() != QProcess::NotRunning) {
                javaAppProcess.waitForFinished(500);
            }
            return true;
        } else {
            return false;
        }
    } else {    
        return okToConnect();
    }
        
}

bool ConnectionManager::okToConnect()
{   
    // See if we're already connected
    if (tcpSocket.state() == QAbstractSocket::ConnectedState) {
        QString peerName = tcpSocket.peerName();
        QString peerPort;
        peerPort.setNum(tcpSocket.peerPort());
        QString msg = "You are currently connected to ";
        msg.append(peerName).append(":").append(peerPort);
        msg.append("\nDo you want to disconnect?");

        int result = QMessageBox::information(dynamic_cast<QWidget*>(parent), "inspectorJ Connection", msg,
                QMessageBox::Yes | QMessageBox::Default, QMessageBox::No);
        if (result == QMessageBox::Yes) {
            closeConnection();
            return true;
        } else {
            return false;
        }
    } else {    
        return true;
    }
}

bool ConnectionManager::attachToServer()
{
    // Get the action that was triggered. The action contains the
    // connection information.
    QAction *action = qobject_cast<QAction *>(sender());
    if (action) {
                
        // See if we're already connected
        if ( !okToConnect()) {
            return false;
        }
        
        QStringList actionData = action->data().toStringList();
        QString profileName;
        QString host;
        QString port;
        profileName = actionData[0];
        host = actionData[1];
        port = actionData[2]; 
        bool ok;
        int portNum = port.toInt(&ok, 10); 
        tcpSocket.connectToHost(host, portNum);
        return true;
    }
    return false;
}

void ConnectionManager::attachToLaunchedServer()
{
    bool ok;
    int portNum = connection.port.toInt(&ok, 10); 
    tcpSocket.connectToHost(connection.host, portNum);    
}

bool ConnectionManager::startAttachTimer(int mills, ijConnection conn)
{
    // See if we're already connected
    if ( !okToConnect()) {
        return false;
    }
        
    this->connection = conn;
    QTimer::singleShot(mills, this, SLOT(attachToLaunchedServer()));
    return true; 
}


void ConnectionManager::launchJavaApp()
{
    // Get the action that was triggered. The action contains the
    // profile information.
    QAction *action = qobject_cast<QAction *>(sender());
    if (action) {
                        
        // See if we're already connected
        if ( !okToLaunch()) {
            return;
        }
        
        QStringList actionData = action->data().toStringList();
        QString profileName;
        profileName = actionData[0];
        
        QString profileDir;
        profileDir = actionData[1];
        QString cmd = buildCmdString(profiles[profileName], profileDir);
        
        javaAppProcess.setWorkingDirectory(QDir::currentPath());
        javaAppProcess.start(cmd);
    }
}

bool isWindows()
{
    return QDir::separator().toAscii() == '\\';
}

QString ConnectionManager::buildCmdString(SessionProfile &profile, QString& 
profileDir)
{
    // Get the native separator for the host os
    QChar sep = QDir::separator();
    
    // Path separator
    QChar pathSep;
    
    if (isWindows()) {
        pathSep = QChar(';');
    } else {
        pathSep = QChar(':');
    }
    
    // Get the inspectorj client's current path
    QString path = QDir::currentPath();
    QString javaExec;
    
    // build the java executable string
    if (profile.isTomcatApp()) {
        javaExec = profile.getApplicationEntry();
        if (!javaExec.endsWith(sep)) {
            javaExec += sep;
        }
        javaExec.append("bin").append(sep).append("catalina.");
        if (isWindows()) {
            javaExec.prepend("\"");
            javaExec.append("bat\"");
        } else {
            javaExec.append("sh");
        }
        javaExec.append(" run");
    } else {
        javaExec = profile.getJreHome();
        if (!javaExec.endsWith(sep)) {
            javaExec += sep;
        }   
        javaExec.append("bin").append(sep).append("java");
        if (isWindows()) {
            javaExec.prepend("\"");
            javaExec.append(".exe\"");
        }
    }
    
    // append the args to be passed to the java command
    QString args;
    QString javaOptions = profile.getJavaOptions();
    if (!javaOptions.isEmpty()) {
        args.append(javaOptions);
    }

    args.append(" -Xbootclasspath/a:\"");
    args.append(path).append(sep).append("mtrace.jar\" ");
    
    // append classpath entries
    QStringList classpaths = profile.getClassPath();
    if (classpaths.size() > 0) {
        args.append("-classpath ");
        for (int i = 0; i < classpaths.size(); i++) {
            args.append(classpaths.at(i));
            // add the path separator
            if (i < classpaths.size() - 1) {
                args.append(pathSep);
            }
        }
    }
    
    QString agentLibOption(" -agentpath:\"");
    agentLibOption.append(path).append(sep);
    if (!isWindows()) {
        agentLibOption.append("lib");
    }
    agentLibOption.append("ij_agent.");
    
    // add the correct file ext (.so or .dll)
    if (isWindows()) {
        agentLibOption.append("dll");
    } else {
        agentLibOption.append("so");
    }
    agentLibOption.append("\"=profile=\"");
    agentLibOption.append(profileDir);
    if (!profileDir.endsWith(sep)) {
        agentLibOption += sep;
    }       
    agentLibOption.append(profile.getFileName()).append("\"");
    agentLibOption.append(",loglevel=99 ");
    args.append(agentLibOption);
    
    if (profile.isJarFile()) {
        if (javaOptions.isEmpty() || !javaOptions.contains("-jar")) {
            args.append(" -jar ");
        }
    }
    
    if (profile.isTomcatApp()) {
        QStringList env = QProcess::systemEnvironment();
        QString javaOpts ("JAVA_OPTS=");
        javaOpts.append(args);
        env << javaOpts;
        QString catalinaHome("CATALINA_HOME=");
        catalinaHome.append(profile.getApplicationEntry());
        env << catalinaHome;
        if (!profile.getJreHome().isEmpty()) {
            QString javaHome("JAVA_HOME=");
            javaHome.append(profile.getJreHome());
            env << javaHome;
        }
        javaAppProcess.setEnvironment(env);        
    } else {
        if (profile.isJarFile()) {
            args.append("\"");
        }
        args.append(profile.getApplicationEntry());
        if (profile.isJarFile()) {
            args.append("\"");
        }
        args.append(" ");
        
        QString appArgs = profile.getApplicationArgs();
        if (!appArgs.isEmpty()) {
            args.append(appArgs);
        }
        
        javaExec.append(args);
    }
    return javaExec;
}

void ConnectionManager::setExiting(bool exit)
{
    this->exiting = exit;
}


void ConnectionManager::sendHandshake()
{
    tcpSocket.write(JDWP_HANDSHAKE, (qint64)14);
}

void ConnectionManager::receiveHandshake()
{
    QString msg;
    handler.getHandshake(attached, msg);
    if (!msg.isEmpty()) {
        if (attached) {
            emit connected(attached, msg);
        } else { 
            // Handshake failed ;-[             
            QMessageBox::warning( dynamic_cast<QWidget*>(parent), "inspectorJ Connection",
                                  msg, QMessageBox::Ok | QMessageBox::Default);
        }
    } else {
        // msg String shouldn't be empty. If so something bad has happened
        QMessageBox::warning( dynamic_cast<QWidget*>(parent), "inspectorJ Connection",
                              "An unexpected error has occurred!",
                              QMessageBox::Ok | QMessageBox::Default);
    }
}

void ConnectionManager::connectionClosedByServer()
{
    closeConnection();  
}

void ConnectionManager::closeConnection()
{
    QAction *action = qobject_cast<QAction *>(sender());
    if (action && action->text() == "&Disconnect") {
        QString msg = "Are you sure you want to disconnect?";
        int result = QMessageBox::information(dynamic_cast<QWidget*>(parent), 
                            "inspectorJ Connection", msg,
                            QMessageBox::Yes | QMessageBox::Default, 
                            QMessageBox::No);
        
        if (result != QMessageBox::Yes) {
            return;
        }
    }
    
    if (!attached) {
        return;
    }
    QAbstractSocket::SocketState state = tcpSocket.state();
    if (state != QAbstractSocket::ClosingState && state != QAbstractSocket::UnconnectedState) {
        JDWPCommand *cmd = JDWPCommand::newCommand(IJ_DISCONNECT);    
        sendRequest(cmd,  NULL);
        tcpSocket.close();
    }
    attached = false;
    QString msg = "Disconnected";
    emit connected(attached, msg);
}

void ConnectionManager::stopJavaApp()
{
    QString msg = "Are you sure you want to terminate the launched process?";
    int result = QMessageBox::information(dynamic_cast<QWidget*>(parent), 
                        "inspectorJ - Stop Java Application", msg,
                        QMessageBox::Yes | QMessageBox::Default, 
                        QMessageBox::No);
    
    if (result != QMessageBox::Yes) {
        return;
    }
    
    QAbstractSocket::SocketState state = tcpSocket.state();
    if (state != QAbstractSocket::ClosingState && state != QAbstractSocket::UnconnectedState) {
        JDWPCommand *cmd = JDWPCommand::newCommand(IJ_EXIT);    
        sendRequest(cmd,  NULL);        
        tcpSocket.close();
    }
    attached = false;
    msg = "Disconnected";
    emit connected(attached, msg);
        
    javaAppProcess.kill();
}

void ConnectionManager::getJDWPError(int errCode, QString &s)
{
    ClientPacketHandler::getJDWPError(errCode, s);
}

void ConnectionManager::error(QAbstractSocket::SocketError error)
{
    if (!exiting) {
        closeConnection();
        QString errMsg;
        handler.getSocketError(error, errMsg);
        QMessageBox::warning( dynamic_cast<QWidget*>(parent), "inspectorJ Connection", errMsg,
                              QMessageBox::Ok | QMessageBox::Default);  
    }
}

---