update record host to work with remote devices

Changes to existing logic:
RecordHost now saved the client app args
RecordHost no longer differentiate between local and remote when setting
the output file name, since the file is always saved on the host

New class RemoteDevice, this class handles communication between the
host and the remote device. It does this by using a multiplexed ssh
connection. This is faster since we only need to do authentification
once and can then reuse the existing connection.

Author: lievenhey

src/CMakeLists.txt

@@ -54,6 +54,7 @@ set(HOTSPOT_SRCS
     perfcontrolfifowrapper.cpp
     errnoutil.cpp
     recordhost.cpp
+    remotedevice.cpp
     # ui files:
     mainwindow.ui
     aboutdialog.ui

src/recordhost.cpp

@@ -140,12 +140,35 @@ RecordHost::PerfCapabilities fetchLocalPerfCapabilities(const QString& perfPath)
 
     return capabilities;
 }
+
+RecordHost::PerfCapabilities fetchRemotePerfCapabilities(const 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")});
+
+    capabilities.canCompress = Zstd_FOUND && buildOptions.contains("zszd: [ on  ]");
+    capabilities.canSwitchEvents = help.contains("--switch-events");
+    capabilities.canSampleCpu = help.contains("--sample-cpu");
+
+    // TODO: implement
+    capabilities.canProfileOffCpu = false;
+    capabilities.privilegesAlreadyElevated = false;
+
+    capabilities.canUseAio = false; // AIO doesn't work with perf streaming
+    capabilities.canElevatePrivileges = false; // we currently don't support this
+
+    return capabilities;
+}
 }
 
 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; });
 
@@ -160,6 +183,10 @@ 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"));
 }
 
@@ -169,7 +196,13 @@ bool RecordHost::isReady() const
 {
     switch (m_recordType) {
     case RecordType::LaunchApplication:
-        // client application is already validated in  the setter
+        // client application is already validated in the setter
+        if (m_clientApplication.isEmpty() && m_cwd.isEmpty())
+            return false;
+        break;
+    case RecordType::LaunchRemoteApplication:
+        if (!m_remoteDevice.isConnected())
+            return false;
         if (m_clientApplication.isEmpty() && m_cwd.isEmpty())
             return false;
         break;
@@ -210,38 +243,19 @@ void RecordHost::setHost(const QString& host)
     m_clientApplication.clear();
     emit clientApplicationChanged(m_clientApplication);
 
+    m_clientApplicationArguments.clear();
+    emit clientApplicationArgumentsChanged(m_clientApplicationArguments);
+
     m_perfCapabilities = {};
     emit perfCapabilitiesChanged(m_perfCapabilities);
 
-    const auto perfPath = perfBinaryPath();
-    m_checkPerfCapabilitiesJob.startJob([perfPath](auto&&) { return fetchLocalPerfCapabilities(perfPath); },
-                                        [this](RecordHost::PerfCapabilities capabilities) {
-                                            Q_ASSERT(QThread::currentThread() == thread());
-
-                                            m_perfCapabilities = capabilities;
-                                            emit perfCapabilitiesChanged(m_perfCapabilities);
-                                        });
-
-    m_checkPerfInstalledJob.startJob(
-        [isLocal = isLocal(), perfPath](auto&&) {
-            if (isLocal) {
-                if (perfPath.isEmpty()) {
-                    return !QStandardPaths::findExecutable(QStringLiteral("perf")).isEmpty();
-                }
-
-                return QFileInfo::exists(perfPath);
-            }
-
-            qWarning() << "remote is not implemented";
-            return false;
-        },
-        [this](bool isInstalled) {
-            if (!isInstalled) {
-                emit errorOccurred(tr("perf is not installed"));
-            }
-            m_isPerfInstalled = isInstalled;
-            emit isPerfInstalledChanged(isInstalled);
-        });
+    m_remoteDevice.disconnect();
+    if (isLocal()) {
+        checkRequirements();
+    } else {
+        // checkRequirements will be called via RemoteDevice::connected
+        m_remoteDevice.connectToDevice(m_host);
+    }
 }
 
 void RecordHost::setCurrentWorkingDirectory(const QString& cwd)
@@ -262,16 +276,25 @@ void RecordHost::setCurrentWorkingDirectory(const QString& cwd)
             m_cwd = cwd;
             emit currentWorkingDirectoryChanged(cwd);
         }
-        return;
+    } else {
+        if (!m_remoteDevice.checkIfDirectoryExists(cwd)) {
+            emit errorOccurred(tr("Working directory folder cannot be found: %1").arg(cwd));
+        } else {
+            emit errorOccurred({});
+            m_cwd = cwd;
+            emit currentWorkingDirectoryChanged(m_cwd);
+        }
     }
-
-    qWarning() << "is not implemented for remote";
 }
 
 void RecordHost::setClientApplication(const QString& clientApplication)
 {
     Q_ASSERT(QThread::currentThread() == thread());
 
+    if (m_clientApplication == clientApplication) {
+        return;
+    }
+
     if (isLocal()) {
         QFileInfo application(KShell::tildeExpand(clientApplication));
         if (!application.exists()) {
@@ -293,38 +316,48 @@ void RecordHost::setClientApplication(const QString& clientApplication)
         if (m_cwd.isEmpty()) {
             setCurrentWorkingDirectory(application.dir().absolutePath());
         }
-        return;
+    } else {
+        if (!m_remoteDevice.checkIfFileExists(clientApplication)) {
+            emit errorOccurred(tr("Application file cannot be found: %1").arg(clientApplication));
+        } else {
+            emit errorOccurred({});
+            m_clientApplication = clientApplication;
+            emit clientApplicationChanged(m_clientApplication);
+        }
     }
-
-    qWarning() << "is not implemented for remote";
 }
 
-void RecordHost::setOutputFileName(const QString& filePath)
+void RecordHost::setClientApplicationArguments(const QString& arguments)
 {
-    if (isLocal()) {
-        const auto perfDataExtension = QStringLiteral(".data");
-
-        const QFileInfo file(filePath);
-        const QFileInfo folder(file.absolutePath());
-
-        if (!folder.exists()) {
-            emit errorOccurred(tr("Output file directory folder cannot be found: %1").arg(folder.path()));
-        } else if (!folder.isDir()) {
-            emit errorOccurred(tr("Output file directory folder is not valid: %1").arg(folder.path()));
-        } else if (!folder.isWritable()) {
-            emit errorOccurred(tr("Output file directory folder is not writable: %1").arg(folder.path()));
-        } else if (!file.absoluteFilePath().endsWith(perfDataExtension)) {
-            emit errorOccurred(tr("Output file must end with %1").arg(perfDataExtension));
-        } else {
-            emit errorOccurred({});
-            m_outputFileName = filePath;
-            emit outputFileNameChanged(m_outputFileName);
-        }
+    Q_ASSERT(QThread::currentThread() == thread());
 
-        return;
+    if (m_clientApplicationArguments != arguments) {
+        m_clientApplicationArguments = arguments;
+        emit clientApplicationArgumentsChanged(m_clientApplicationArguments);
     }
+}
 
-    qWarning() << "is not implemented for remote";
+void RecordHost::setOutputFileName(const QString& filePath)
+{
+    const auto perfDataExtension = QStringLiteral(".data");
+    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
+    if (!folder.exists()) {
+        emit errorOccurred(tr("Output file directory folder cannot be found: %1").arg(folder.path()));
+    } else if (!folder.isDir()) {
+        emit errorOccurred(tr("Output file directory folder is not valid: %1").arg(folder.path()));
+    } else if (!folder.isWritable()) {
+        emit errorOccurred(tr("Output file directory folder is not writable: %1").arg(folder.path()));
+    } else if (!file.absoluteFilePath().endsWith(perfDataExtension)) {
+        emit errorOccurred(tr("Output file must end with %1").arg(perfDataExtension));
+    } else {
+        emit errorOccurred({});
+        m_outputFileName = filePath;
+        emit outputFileNameChanged(m_outputFileName);
+    }
 }
 
 void RecordHost::setRecordType(RecordType type)
@@ -366,3 +399,44 @@ QString RecordHost::perfBinaryPath() const
     }
     return {};
 }
+
+void RecordHost::checkRequirements()
+{
+    const auto perfPath = perfBinaryPath();
+    m_checkPerfCapabilitiesJob.startJob(
+        [isLocal = isLocal(), &remoteDevice = m_remoteDevice, perfPath](auto&&) {
+            if (isLocal) {
+                return fetchLocalPerfCapabilities(perfPath);
+            } else {
+                return fetchRemotePerfCapabilities(remoteDevice);
+            }
+        },
+        [this](RecordHost::PerfCapabilities capabilities) {
+            Q_ASSERT(QThread::currentThread() == thread());
+
+            m_perfCapabilities = capabilities;
+            emit perfCapabilitiesChanged(m_perfCapabilities);
+        });
+
+    m_checkPerfInstalledJob.startJob(
+        [isLocal = isLocal(), &remoteDevice = m_remoteDevice, perfPath](auto&&) {
+            if (isLocal) {
+                if (perfPath.isEmpty()) {
+                    return !QStandardPaths::findExecutable(QStringLiteral("perf")).isEmpty();
+                }
+
+                return QFileInfo::exists(perfPath);
+            } else {
+                return remoteDevice.checkIfProgramExists(QStringLiteral("perf"));
+            }
+
+            return false;
+        },
+        [this](bool isInstalled) {
+            if (!isInstalled) {
+                emit errorOccurred(tr("perf is not installed"));
+            }
+            m_isPerfInstalled = isInstalled;
+            emit isPerfInstalledChanged(isInstalled);
+        });
+}

src/recordhost.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "jobtracker.h"
+#include "remotedevice.h"
 
 #include <QObject>
 
@@ -60,6 +61,12 @@ class RecordHost : public QObject
     }
     void setClientApplication(const QString& clientApplication);
 
+    QString clientApplicationArguments() const
+    {
+        return m_clientApplicationArguments;
+    }
+    void setClientApplicationArguments(const QString& arguments);
+
     QString outputFileName() const
     {
         return m_outputFileName;
@@ -104,26 +111,30 @@ class RecordHost : public QObject
     void hostChanged();
     void currentWorkingDirectoryChanged(const QString& cwd); // Maybe QUrl
     void clientApplicationChanged(const QString& clientApplication);
+    void clientApplicationArgumentsChanged(const QString& arguments);
     void perfCapabilitiesChanged(RecordHost::PerfCapabilities perfCapabilities);
     void isPerfInstalledChanged(bool isInstalled);
     void outputFileNameChanged(const QString& outputFileName);
     void recordTypeChanged(RecordType type);
     void pidsChanged();
 
 private:
+    void checkRequirements();
     bool isLocal() const;
 
     QString m_host;
     QString m_error;
     QString m_cwd;
     QString m_clientApplication;
+    QString m_clientApplicationArguments;
     QString m_outputFileName;
     PerfCapabilities m_perfCapabilities;
     JobTracker m_checkPerfCapabilitiesJob;
     JobTracker m_checkPerfInstalledJob;
     RecordType m_recordType = RecordType::LaunchApplication;
     bool m_isPerfInstalled = false;
     QStringList m_pids;
+    RemoteDevice m_remoteDevice;
 };
 
 Q_DECLARE_METATYPE(RecordHost::PerfCapabilities)

src/recordpage.cpp

@@ -203,7 +203,8 @@ RecordPage::RecordPage(QWidget* parent)
             });
 
     connect(ui->applicationParametersBox, &QLineEdit::editingFinished, this, [this] {
-        ui->multiConfig->saveCurrentConfig(); // TODO: set app params
+        ui->multiConfig->saveCurrentConfig();
+        m_recordHost->setClientApplicationArguments(ui->applicationParametersBox->text());
     });
 
     ui->compressionComboBox->addItem(tr("Disabled"), -1);