add recording via ssh

this patch finally runs perf via ssh on a remote device
perf is run with -o - to stream the recording to the host
in this case stderr contains the output of the program run

Author: lievenhey

src/perfrecord.cpp

@@ -70,60 +70,30 @@ bool PerfRecord::runPerf(bool elevatePrivileges, const QStringList& perfOptions,
         m_perfControlFifo.close();
         m_perfRecordProcess->kill();
     }
-    m_perfRecordProcess = std::make_unique<QProcess>(this);
-    m_perfRecordProcess->setProcessChannelMode(QProcess::MergedChannels);
 
-    const auto outputFileInfo = QFileInfo(outputPath);
-    const auto folderPath = outputFileInfo.dir().path();
-    const auto folderInfo = QFileInfo(folderPath);
-    if (!folderInfo.exists()) {
-        emit recordingFailed(tr("Folder '%1' does not exist.").arg(folderPath));
-        return false;
-    }
-    if (!folderInfo.isDir()) {
-        emit recordingFailed(tr("'%1' is not a folder.").arg(folderPath));
-        return false;
-    }
-    if (!folderInfo.isWritable()) {
-        emit recordingFailed(tr("Folder '%1' is not writable.").arg(folderPath));
-        return false;
-    }
-
-    connect(m_perfRecordProcess.get(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
-            this, [this](int exitCode, QProcess::ExitStatus exitStatus) {
-                Q_UNUSED(exitStatus)
+    m_outputPath = outputPath;
+    m_userTerminated = false;
 
-                const auto outputFileInfo = QFileInfo(m_outputPath);
-                if ((exitCode == EXIT_SUCCESS || (exitCode == SIGTERM && m_userTerminated) || outputFileInfo.size() > 0)
-                    && outputFileInfo.exists()) {
-                    if (exitCode != EXIT_SUCCESS && !m_userTerminated) {
-                        emit debuggeeCrashed();
-                    }
-                    emit recordingFinished(m_outputPath);
-                } else {
-                    emit recordingFailed(tr("Failed to record perf data, error code %1.").arg(exitCode));
-                }
-                m_userTerminated = false;
-            });
+    if (m_host->isLocal()) {
+        return runPerfLocal(elevatePrivileges, perfOptions, outputPath, workingDirectory);
+    } else {
+        return runPerfRemote(perfOptions, outputPath, workingDirectory);
+    }
+}
 
-    connect(m_perfRecordProcess.get(), &QProcess::errorOccurred, this, [this](QProcess::ProcessError error) {
-        Q_UNUSED(error)
-        if (!m_userTerminated) {
-            emit recordingFailed(m_perfRecordProcess->errorString());
-        }
-    });
+bool PerfRecord::runPerfLocal(bool elevatePrivileges, const QStringList& perfOptions, const QString& outputPath,
+                              const QString& workingDirectory)
+{
+    m_perfRecordProcess = std::make_unique<QProcess>(this);
+    m_perfRecordProcess->setProcessChannelMode(QProcess::MergedChannels);
 
-    connect(m_perfRecordProcess.get(), &QProcess::started, this,
-            [this] { emit recordingStarted(m_perfRecordProcess->program(), m_perfRecordProcess->arguments()); });
+    connectRecordingProcessErrors();
 
     connect(m_perfRecordProcess.get(), &QProcess::readyRead, this, [this]() {
         const auto output = QString::fromUtf8(m_perfRecordProcess->readAll());
         emit recordingOutput(output);
     });
 
-    m_outputPath = outputPath;
-    m_userTerminated = false;
-
     if (!workingDirectory.isEmpty()) {
         m_perfRecordProcess->setWorkingDirectory(workingDirectory);
     }
@@ -160,6 +130,36 @@ bool PerfRecord::runPerf(bool elevatePrivileges, const QStringList& perfOptions,
     return true;
 }
 
+bool PerfRecord::runPerfRemote(const QStringList& perfOptions, const QString& outputPath,
+                               const QString& workingDirectory)
+{
+    m_perfRecordProcess = m_host->remoteDevice()->runPerf(workingDirectory, perfOptions);
+
+    auto output = new QFile(outputPath, m_perfRecordProcess.get());
+    if (!output->open(QIODevice::WriteOnly)) {
+        emit recordingFailed(QStringLiteral("Failed to create output file: %1").arg(outputPath));
+        return false;
+    }
+
+    connect(m_perfRecordProcess.get(), &QProcess::readyReadStandardOutput, m_perfRecordProcess.get(),
+            [process = m_perfRecordProcess.get(), output] {
+                auto data = process->readAllStandardOutput();
+                output->write(data);
+            });
+    connect(m_perfRecordProcess.get(), &QProcess::readyReadStandardError, m_perfRecordProcess.get(),
+            [this] { emit recordingOutput(QString::fromUtf8(m_perfRecordProcess->readAllStandardError())); });
+
+    connect(m_perfRecordProcess.get(), qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this, [output] {
+        output->close();
+        output->deleteLater();
+    });
+
+    connectRecordingProcessErrors();
+
+    m_perfRecordProcess->start();
+    return true;
+}
+
 void PerfRecord::record(const QStringList& perfOptions, const QString& outputPath, bool elevatePrivileges,
                         const QStringList& pids)
 {
@@ -245,3 +245,33 @@ bool PerfRecord::actuallyElevatePrivileges(bool elevatePrivileges) const
     const auto capabilities = m_host->perfCapabilities();
     return elevatePrivileges && capabilities.canElevatePrivileges && !capabilities.privilegesAlreadyElevated;
 }
+
+void PerfRecord::connectRecordingProcessErrors()
+{
+    connect(m_perfRecordProcess.get(), qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this,
+            [this](int exitCode, QProcess::ExitStatus exitStatus) {
+                Q_UNUSED(exitStatus)
+
+                const auto outputFileInfo = QFileInfo(m_outputPath);
+                if ((exitCode == EXIT_SUCCESS || (exitCode == SIGTERM && m_userTerminated) || outputFileInfo.size() > 0)
+                    && outputFileInfo.exists()) {
+                    if (exitCode != EXIT_SUCCESS && !m_userTerminated) {
+                        emit debuggeeCrashed();
+                    }
+                    emit recordingFinished(m_outputPath);
+                } else {
+                    emit recordingFailed(tr("Failed to record perf data, error code %1.").arg(exitCode));
+                }
+                m_userTerminated = false;
+            });
+
+    connect(m_perfRecordProcess.get(), &QProcess::errorOccurred, this, [this](QProcess::ProcessError error) {
+        Q_UNUSED(error)
+        if (!m_userTerminated) {
+            emit recordingFailed(m_perfRecordProcess->errorString());
+        }
+    });
+
+    connect(m_perfRecordProcess.get(), &QProcess::started, this,
+            [this] { emit recordingStarted(m_perfRecordProcess->program(), m_perfRecordProcess->arguments()); });
+}

src/perfrecord.h

@@ -12,10 +12,10 @@
 #include "perfcontrolfifowrapper.h"
 
 #include <QObject>
+#include <QProcess>
 
 #include <memory>
 
-class QProcess;
 class RecordHost;
 
 class PerfRecord : public QObject
@@ -57,5 +57,12 @@ class PerfRecord : public QObject
     bool runPerf(bool elevatePrivileges, const QStringList& perfOptions, const QString& outputPath,
                  const QString& workingDirectory = QString());
 
+    bool runPerfLocal(bool elevatePrivileges, const QStringList& perfOptions, const QString& outputPath,
+                      const QString& workingDirectory = QString());
+    bool runPerfRemote(const QStringList& perfOptions, const QString& outputPath,
+                       const QString& workingDirectory = QString());
+
     bool runRemotePerf(const QStringList& perfOptions, const QString& outputPath, const QString& workingDirectory = {});
+
+    void connectRecordingProcessErrors();
 };

src/recordhost.cpp

@@ -143,13 +143,13 @@ RecordHost::PerfCapabilities fetchLocalPerfCapabilities(const QString& perfPath)
     return capabilities;
 }
 
-RecordHost::PerfCapabilities fetchRemotePerfCapabilities(const RemoteDevice& device)
+RecordHost::PerfCapabilities fetchRemotePerfCapabilities(const std::unique_ptr<RemoteDevice>& device)
 {
     RecordHost::PerfCapabilities capabilities;
 
-    const auto buildOptions =
-        device.getProgramOutput({QStringLiteral("perf"), QStringLiteral("version"), QStringLiteral("--build-options")});
-    const auto help = device.getProgramOutput({QStringLiteral("perf"), QStringLiteral("--help")});
+    const auto buildOptions = device->getProgramOutput(
+        {QStringLiteral("perf"), QStringLiteral("version"), QStringLiteral("--build-options")});
+    const auto help = device->getProgramOutput({QStringLiteral("perf"), QStringLiteral("--help")});
 
     capabilities.canCompress = Zstd_FOUND && buildOptions.contains("zszd: [ on  ]");
     capabilities.canSwitchEvents = help.contains("--switch-events");
@@ -170,7 +170,6 @@ RecordHost::RecordHost(QObject* parent)
     : QObject(parent)
     , m_checkPerfCapabilitiesJob(this)
     , m_checkPerfInstalledJob(this)
-    , m_remoteDevice(this)
 {
     connect(this, &RecordHost::errorOccurred, this, [this](const QString& message) { m_error = message; });
 
@@ -185,10 +184,6 @@ RecordHost::RecordHost(QObject* parent)
     connectIsReady(&RecordHost::pidsChanged);
     connectIsReady(&RecordHost::currentWorkingDirectoryChanged);
 
-    connect(&m_remoteDevice, &RemoteDevice::connected, this, &RecordHost::checkRequirements);
-
-    connect(&m_remoteDevice, &RemoteDevice::connected, this, [this] { emit isReadyChanged(isReady()); });
-
     setHost(QStringLiteral("localhost"));
 }
 
@@ -203,7 +198,7 @@ bool RecordHost::isReady() const
             return false;
         break;
     case RecordType::LaunchRemoteApplication:
-        if (!m_remoteDevice.isConnected())
+        if (!m_remoteDevice || !m_remoteDevice->isConnected())
             return false;
         if (m_clientApplication.isEmpty() && m_cwd.isEmpty())
             return false;
@@ -238,6 +233,17 @@ void RecordHost::setHost(const QString& host)
     m_host = host;
     emit hostChanged();
 
+    if (!isLocal()) {
+        m_remoteDevice = std::make_unique<RemoteDevice>(this);
+
+        connect(m_remoteDevice.get(), &RemoteDevice::connected, this, &RecordHost::checkRequirements);
+        connect(m_remoteDevice.get(), &RemoteDevice::connected, this, [this] { emit isReadyChanged(isReady()); });
+        connect(m_remoteDevice.get(), &RemoteDevice::failedToConnect, this,
+                [this] { emit errorOccurred(tr("Failed to connect to: %1").arg(m_host)); });
+    } else {
+        m_remoteDevice = nullptr;
+    }
+
     // invalidate everything
     m_cwd.clear();
     emit currentWorkingDirectoryChanged(m_cwd);
@@ -251,12 +257,11 @@ void RecordHost::setHost(const QString& host)
     m_perfCapabilities = {};
     emit perfCapabilitiesChanged(m_perfCapabilities);
 
-    m_remoteDevice.disconnect();
     if (isLocal()) {
         checkRequirements();
     } else {
         // checkRequirements will be called via RemoteDevice::connected
-        m_remoteDevice.connectToDevice(m_host);
+        m_remoteDevice->connectToDevice(m_host);
     }
 }
 
@@ -279,7 +284,7 @@ void RecordHost::setCurrentWorkingDirectory(const QString& cwd)
             emit currentWorkingDirectoryChanged(cwd);
         }
     } else {
-        if (!m_remoteDevice.checkIfDirectoryExists(cwd)) {
+        if (!m_remoteDevice->checkIfDirectoryExists(cwd)) {
             emit errorOccurred(tr("Working directory folder cannot be found: %1").arg(cwd));
         } else {
             emit errorOccurred({});
@@ -319,7 +324,9 @@ void RecordHost::setClientApplication(const QString& clientApplication)
             setCurrentWorkingDirectory(application.dir().absolutePath());
         }
     } else {
-        if (!m_remoteDevice.checkIfFileExists(clientApplication)) {
+        if (!m_remoteDevice->isConnected()) {
+            emit errorOccurred(tr("Hotspot is not connected to the remote device"));
+        } else if (!m_remoteDevice->checkIfFileExists(clientApplication)) {
             emit errorOccurred(tr("Application file cannot be found: %1").arg(clientApplication));
         } else {
             emit errorOccurred({});
@@ -345,8 +352,8 @@ void RecordHost::setOutputFileName(const QString& filePath)
     const QFileInfo file(filePath);
     const QFileInfo folder(file.absolutePath());
 
-    // the recording data is streamed from the device (currently) so there is no need to use different logic for local
-    // vs remote
+    // the recording data is streamed from the device (currently) so there is no need to use different logic for
+    // local vs remote
     if (!folder.exists()) {
         emit errorOccurred(tr("Output file directory folder cannot be found: %1").arg(folder.path()));
     } else if (!folder.isDir()) {
@@ -429,7 +436,7 @@ void RecordHost::checkRequirements()
 
                 return QFileInfo::exists(perfPath);
             } else {
-                return remoteDevice.checkIfProgramExists(QStringLiteral("perf"));
+                return remoteDevice->checkIfProgramExists(QStringLiteral("perf"));
             }
 
             return false;
@@ -442,3 +449,12 @@ void RecordHost::checkRequirements()
             emit isPerfInstalledChanged(isInstalled);
         });
 }
+
+void RecordHost::disconnectFromDevice()
+{
+    if (!isLocal()) {
+        if (m_remoteDevice->isConnected()) {
+            m_remoteDevice->disconnect();
+        }
+    }
+}

src/recordhost.h

@@ -12,6 +12,8 @@
 
 #include <QObject>
 
+#include <memory>
+
 enum class RecordType
 {
     LaunchApplication,
@@ -104,6 +106,15 @@ class RecordHost : public QObject
     // list of pids to record
     void setPids(const QStringList& pids);
 
+    bool isLocal() const;
+
+    const RemoteDevice* remoteDevice() const
+    {
+        return m_remoteDevice.get();
+    }
+
+    void disconnectFromDevice();
+
 signals:
     /// disallow "start" on recordpage until this is ready and that should only be the case when there's no error
     void isReadyChanged(bool isReady);
@@ -121,7 +132,6 @@ class RecordHost : public QObject
 
 private:
     void checkRequirements();
-    bool isLocal() const;
 
     QString m_host;
     QString m_error;
@@ -135,7 +145,7 @@ class RecordHost : public QObject
     RecordType m_recordType = RecordType::LaunchApplication;
     bool m_isPerfInstalled = false;
     QStringList m_pids;
-    RemoteDevice m_remoteDevice;
+    std::unique_ptr<RemoteDevice> m_remoteDevice;
 };
 
 Q_DECLARE_METATYPE(RecordHost::PerfCapabilities)