Commit 86781175 authored by hjk's avatar hjk

Valgrind: Merge ValgrindRunner and ValgrindProcess

There was a 1:1 matching remaining.

Change-Id: I619bedcda867b642eab37396a0bd48bcb3a5829a
Reviewed-by: Christian Kandeler's avatarChristian Kandeler <christian.kandeler@qt.io>
parent 7a09bb44
......@@ -31,7 +31,6 @@
#include <valgrind/callgrind/callgrindcontroller.h>
#include <valgrind/callgrind/callgrindparser.h>
#include <valgrind/valgrindrunner.h>
#include <valgrind/valgrindprocess.h>
#include <debugger/analyzer/analyzermanager.h>
......@@ -62,7 +61,7 @@ CallgrindToolRunner::CallgrindToolRunner(RunControl *runControl)
connect(&m_controller, &CallgrindController::statusMessage,
this, &CallgrindToolRunner::showStatusMessage);
connect(m_runner.valgrindProcess(), &ValgrindProcess::valgrindStarted,
connect(&m_runner, &ValgrindRunner::valgrindStarted,
&m_controller, &CallgrindController::setValgrindPid);
connect(&m_runner, &ValgrindRunner::extraProcessFinished, this, [this] {
......
......@@ -26,7 +26,6 @@
#include "memcheckengine.h"
#include "memchecktool.h"
#include "valgrindprocess.h"
#include "valgrindsettings.h"
#include "xmlprotocol/error.h"
#include "xmlprotocol/status.h"
......
......@@ -31,6 +31,8 @@
#include "valgrindrunner.h"
#include "xmlprotocol/threadedparser.h"
#include <QHostAddress>
namespace Valgrind {
namespace Internal {
......
......@@ -11,7 +11,6 @@ HEADERS += \
valgrindconfigwidget.h \
valgrindsettings.h \
valgrindrunner.h \
valgrindprocess.h \
callgrindcostdelegate.h \
callgrindcostview.h \
callgrindhelper.h \
......@@ -33,7 +32,6 @@ SOURCES += \
valgrindconfigwidget.cpp \
valgrindsettings.cpp \
valgrindrunner.cpp \
valgrindprocess.cpp \
callgrindcostdelegate.cpp \
callgrindcostview.cpp \
callgrindhelper.cpp \
......
......@@ -34,7 +34,6 @@ QtcPlugin {
"valgrindconfigwidget.cpp", "valgrindconfigwidget.h", "valgrindconfigwidget.ui",
"valgrindengine.cpp", "valgrindengine.h",
"valgrindplugin.cpp", "valgrindplugin.h",
"valgrindprocess.cpp", "valgrindprocess.h",
"valgrindruncontrolfactory.cpp", "valgrindruncontrolfactory.h",
"valgrindrunner.cpp", "valgrindrunner.h",
"valgrindsettings.cpp", "valgrindsettings.h",
......
......@@ -27,8 +27,7 @@ HEADERS += \
$$PWD/callgrind/callgrindcycledetection.h \
$$PWD/callgrind/callgrindproxymodel.h \
$$PWD/callgrind/callgrindstackbrowser.h \
$$PWD/valgrindrunner.h \
$$PWD/valgrindprocess.h
$$PWD/valgrindrunner.h
SOURCES += $$PWD/xmlprotocol/error.cpp \
$$PWD/xmlprotocol/frame.cpp \
......@@ -53,7 +52,6 @@ SOURCES += $$PWD/xmlprotocol/error.cpp \
$$PWD/callgrind/callgrindcycledetection.cpp \
$$PWD/callgrind/callgrindproxymodel.cpp \
$$PWD/callgrind/callgrindstackbrowser.cpp \
$$PWD/valgrindrunner.cpp \
$$PWD/valgrindprocess.cpp
$$PWD/valgrindrunner.cpp
LIBS += -L$$IDE_PLUGIN_PATH/QtProject
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Author: Milian Wolff, KDAB (milian.wolff@kdab.com)
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "valgrindprocess.h"
#include <ssh/sshconnectionmanager.h>
#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <utils/qtcprocess.h>
#include <QDebug>
#include <QEventLoop>
using namespace ProjectExplorer;
namespace Valgrind {
ValgrindProcess::ValgrindProcess()
{
}
ValgrindProcess::~ValgrindProcess()
{
}
void ValgrindProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
{
m_valgrindProcess.setProcessChannelMode(mode);
}
QString ValgrindProcess::workingDirectory() const
{
return m_debuggee.workingDirectory;
}
bool ValgrindProcess::isRunning() const
{
return m_valgrindProcess.isRunning();
}
void ValgrindProcess::setValgrindExecutable(const QString &valgrindExecutable)
{
m_valgrindExecutable = valgrindExecutable;
}
void ValgrindProcess::setDebuggee(const StandardRunnable &debuggee)
{
m_debuggee = debuggee;
}
void ValgrindProcess::setValgrindArguments(const QStringList &valgrindArguments)
{
m_valgrindArguments = valgrindArguments;
}
void ValgrindProcess::close()
{
m_valgrindProcess.stop();
}
void ValgrindProcess::run(ApplicationLauncher::Mode runMode)
{
connect(&m_valgrindProcess, &ApplicationLauncher::processExited,
this, &ValgrindProcess::finished);
connect(&m_valgrindProcess, &ApplicationLauncher::processStarted,
this, &ValgrindProcess::localProcessStarted);
connect(&m_valgrindProcess, &ApplicationLauncher::error,
this, &ValgrindProcess::error);
connect(&m_valgrindProcess, &ApplicationLauncher::appendMessage,
this, &ValgrindProcess::processOutput);
connect(&m_valgrindProcess, &ApplicationLauncher::remoteStderr,
this, &ValgrindProcess::handleRemoteStderr);
connect(&m_valgrindProcess, &ApplicationLauncher::remoteStdout,
this, &ValgrindProcess::handleRemoteStdout);
connect(&m_valgrindProcess, &ApplicationLauncher::finished,
this, &ValgrindProcess::closed);
connect(&m_valgrindProcess, &ApplicationLauncher::remoteProcessStarted,
this, &ValgrindProcess::remoteProcessStarted);
StandardRunnable valgrind;
valgrind.executable = m_valgrindExecutable;
valgrind.workingDirectory = m_debuggee.workingDirectory;
valgrind.environment = m_debuggee.environment;
valgrind.runMode = runMode;
valgrind.device = m_device;
if (isLocal()) {
valgrind.commandLineArguments = argumentString(Utils::HostOsInfo::hostOs());
m_valgrindProcess.start(valgrind);
} else {
valgrind.commandLineArguments = argumentString(Utils::OsTypeLinux);
m_valgrindProcess.start(valgrind, m_device);
}
}
QString ValgrindProcess::errorString() const
{
return m_valgrindProcess.errorString();
}
QProcess::ProcessError ValgrindProcess::processError() const
{
return m_valgrindProcess.processError();
}
void ValgrindProcess::handleRemoteStderr(const QByteArray &b)
{
if (!b.isEmpty())
emit processOutput(QString::fromUtf8(b), Utils::StdErrFormat);
}
void ValgrindProcess::handleRemoteStdout(const QByteArray &b)
{
if (!b.isEmpty())
emit processOutput(QString::fromUtf8(b), Utils::StdOutFormat);
}
bool ValgrindProcess::isLocal() const
{
return m_device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
}
void ValgrindProcess::localProcessStarted()
{
qint64 pid = m_valgrindProcess.applicationPID().pid();
emit valgrindStarted(pid);
}
void ValgrindProcess::remoteProcessStarted()
{
// find out what PID our process has
// NOTE: valgrind cloaks its name,
// e.g.: valgrind --tool=memcheck foobar
// => ps aux, pidof will see valgrind.bin
// => pkill/killall/top... will see memcheck-amd64-linux or similar
// hence we need to do something more complex...
// plain path to exe, m_valgrindExe contains e.g. env vars etc. pp.
const QString proc = m_valgrindExecutable.split(' ').last();
StandardRunnable findPid;
findPid.executable = "/bin/sh";
// sleep required since otherwise we might only match "bash -c..."
// and not the actual valgrind run
findPid.commandLineArguments = QString("-c \""
"sleep 1; ps ax" // list all processes with aliased name
" | grep '\\b%1.*%2'" // find valgrind process
" | tail -n 1" // limit to single process
// we pick the last one, first would be "bash -c ..."
" | awk '{print $1;}'" // get pid
"\""
).arg(proc, Utils::FileName::fromString(m_debuggee.executable).fileName());
// m_remote.m_findPID = m_remote.m_connection->createRemoteProcess(cmd.toUtf8());
connect(&m_findPID, &ApplicationLauncher::remoteStderr,
this, &ValgrindProcess::handleRemoteStderr);
connect(&m_findPID, &ApplicationLauncher::remoteStdout,
this, &ValgrindProcess::findPIDOutputReceived);
m_findPID.start(findPid, m_device);
}
void ValgrindProcess::findPIDOutputReceived(const QByteArray &out)
{
if (out.isEmpty())
return;
bool ok;
qint64 pid = out.trimmed().toLongLong(&ok);
if (!ok) {
// m_remote.m_errorString = tr("Could not determine remote PID.");
// emit ValgrindProcess::error(QProcess::FailedToStart);
// close();
} else {
emit valgrindStarted(pid);
}
}
QString ValgrindProcess::argumentString(Utils::OsType osType) const
{
QString arguments = Utils::QtcProcess::joinArgs(m_valgrindArguments, osType);
if (!m_debuggee.executable.isEmpty())
Utils::QtcProcess::addArg(&arguments, m_debuggee.executable, osType);
Utils::QtcProcess::addArgs(&arguments, m_debuggee.commandLineArguments);
return arguments;
}
void ValgrindProcess::setDevice(const ProjectExplorer::IDevice::ConstPtr &device)
{
m_device = device;
}
void ValgrindProcess::closed(bool success)
{
Q_UNUSED(success);
// QTC_ASSERT(m_remote.m_process, return);
// m_remote.m_errorString = m_remote.m_process->errorString();
// if (status == QSsh::SshRemoteProcess::FailedToStart) {
// m_remote.m_error = QProcess::FailedToStart;
// emit ValgrindProcess::error(QProcess::FailedToStart);
// } else if (status == QSsh::SshRemoteProcess::NormalExit) {
// emit finished(m_remote.m_process->exitCode(), QProcess::NormalExit);
// } else if (status == QSsh::SshRemoteProcess::CrashExit) {
// m_remote.m_error = QProcess::Crashed;
// emit finished(m_remote.m_process->exitCode(), QProcess::CrashExit);
// }
emit finished(0, QProcess::NormalExit);
}
} // namespace Valgrind
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Author: Milian Wolff, KDAB (milian.wolff@kdab.com)
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include <projectexplorer/applicationlauncher.h>
#include <projectexplorer/devicesupport/idevice.h>
#include <projectexplorer/runnables.h>
#include <ssh/sshremoteprocess.h>
#include <ssh/sshconnection.h>
#include <utils/osspecificaspects.h>
#include <utils/outputformat.h>
namespace Valgrind {
/**
* Process for supplying local and remote valgrind runs
*/
class ValgrindProcess : public QObject
{
Q_OBJECT
public:
ValgrindProcess();
~ValgrindProcess();
bool isRunning() const;
void setValgrindExecutable(const QString &valgrindExecutable);
void setValgrindArguments(const QStringList &valgrindArguments);
void setDebuggee(const ProjectExplorer::StandardRunnable &debuggee);
void run(ProjectExplorer::ApplicationLauncher::Mode runMode);
void close();
QString errorString() const;
QProcess::ProcessError processError() const;
void setProcessChannelMode(QProcess::ProcessChannelMode mode);
QString workingDirectory() const;
ProjectExplorer::IDevice::ConstPtr device() const { return m_device; }
void setDevice(const ProjectExplorer::IDevice::ConstPtr &device);
bool isLocal() const;
signals:
void valgrindStarted(qint64 pid);
void finished(int, QProcess::ExitStatus);
void error(QProcess::ProcessError);
void processOutput(const QString &, Utils::OutputFormat format);
private:
void handleRemoteStderr(const QByteArray &b);
void handleRemoteStdout(const QByteArray &b);
void closed(bool success);
void localProcessStarted();
void remoteProcessStarted();
void findPIDOutputReceived(const QByteArray &out);
QString argumentString(Utils::OsType osType) const;
ProjectExplorer::StandardRunnable m_debuggee;
ProjectExplorer::ApplicationLauncher m_valgrindProcess;
ProjectExplorer::IDevice::ConstPtr m_device;
ProjectExplorer::ApplicationLauncher m_findPID;
QSsh::SshConnectionParameters m_params;
QString m_valgrindExecutable;
QStringList m_valgrindArguments;
};
} // namespace Valgrind
This diff is collapsed.
......@@ -31,7 +31,6 @@
#include <projectexplorer/runnables.h>
#include <utils/outputformat.h>
#include <ssh/sshconnection.h>
#include <QProcess>
......@@ -39,8 +38,6 @@ namespace Valgrind {
namespace XmlProtocol { class ThreadedParser; }
class ValgrindProcess;
class ValgrindRunner : public QObject
{
Q_OBJECT
......@@ -49,17 +46,12 @@ public:
explicit ValgrindRunner(QObject *parent = 0);
~ValgrindRunner();
QString valgrindExecutable() const;
void setValgrindExecutable(const QString &executable);
QStringList valgrindArguments() const;
QStringList fullValgrindArguments() const;
void setValgrindArguments(const QStringList &toolArguments);
void setDebuggee(const ProjectExplorer::StandardRunnable &debuggee) ;
void setDebuggee(const ProjectExplorer::StandardRunnable &debuggee);
void setProcessChannelMode(QProcess::ProcessChannelMode mode);
void setLocalServerAddress(const QHostAddress &localServerAddress);
void setDevice(const ProjectExplorer::IDevice::ConstPtr &device);
ProjectExplorer::IDevice::ConstPtr device() const;
void waitForFinished() const;
void setToolName(const QString &toolName);
......@@ -69,14 +61,10 @@ public:
bool start();
void stop();
ValgrindProcess *valgrindProcess() const;
XmlProtocol::ThreadedParser *parser() const;
void disableXml();
signals:
void logMessageReceived(const QByteArray &);
void processOutputReceived(const QString &, Utils::OutputFormat);
void processErrorReceived(const QString &, QProcess::ProcessError);
void valgrindStarted(qint64 pid);
......@@ -85,13 +73,9 @@ signals:
private:
bool startServers();
QStringList memcheckLogArguments() const;
void onValgrindStarted(qint64 pid);
void processError(QProcess::ProcessError);
void processFinished(int, QProcess::ExitStatus);
void localHostAddressRetrieved(const QHostAddress &localHostAddress);
void xmlSocketConnected();
void logSocketConnected();
void readLogSocket();
......
......@@ -27,7 +27,6 @@ QtcAutotest {
name: "Other files from plugin"
prefix: product.pluginDir + "/"
files: [
"valgrindprocess.h", "valgrindprocess.cpp",
"valgrindrunner.h", "valgrindrunner.cpp",
]
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment