Differential D27513 Diff 76085 runners/kill/killrunner.cpp

Changeset View

Standalone View

View Options

runners/kill/killrunner.cpp

1/* Copyright 2009 Jan Gerrit Marker <jangerrit@weiler-marker.com> 1​/* Copyright 2009 Jan Gerrit Marker <jangerrit@weiler-marker.com>
2​ * Copyright 2020 Alexander Lohnau <alexander.lohnau@gmx.de>
2 * 3​ *
3 * This library is free software; you can redistribute it and/or 4​ * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public 5​ * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either 6​ * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) version 3, or any 7​ * version 2.1 of the License, or (at your option) version 3, or any
7 * later version accepted by the membership of KDE e.V. (or its 8​ * later version accepted by the membership of KDE e.V. (or its
8 * successor approved by the membership of KDE e.V.), which shall 9​ * successor approved by the membership of KDE e.V.), which shall
9 * act as a proxy defined in Section 6 of version 3 of the license. 10​ * act as a proxy defined in Section 6 of version 3 of the license.
Show All 10 Lines
20#include "killrunner.h" 21​#include "killrunner.h"
21 22​
22#include <QAction> 23​#include <QAction>
23#include <QDebug> 24​#include <QDebug>
24#include <QIcon> 25​#include <QIcon>
25 26​
26#include <KProcess> 27​#include <KProcess>
27#include <KUser> 28​#include <KUser>
28#include <kauth.h> 29​#include <KLocalizedString>
30​#include <KAuth>
29 31​
30#include "processcore/processes.h" 32​#include <processcore/processes.h>
31#include "processcore/process.h" 33​#include <processcore/process.h>
32 ​
33#include "killrunner_config.h" ​
34 34​
35K_EXPORT_PLASMA_RUNNER(kill, KillRunner) 35​K_EXPORT_PLASMA_RUNNER(kill, KillRunner)
36 36​
37KillRunner::KillRunner(QObject *parent, const QVariantList& args) 37​KillRunner::KillRunner(QObject *parent, const QVariantList& args)
38 : Plasma::AbstractRunner(parent, args), 38​ : Plasma::AbstractRunner(parent, args), m_processes(nullptr)
39 m_processes(nullptr) ​
40{ 39​{
41 Q_UNUSED(args); 40​ setObjectName(QStringLiteral("Kill Runner"));
42 setObjectName( QLatin1String("Kill Runner") ); 41​
43 reloadConfiguration(); 42​ addAction(QStringLiteral("SIGTERM"), QIcon::fromTheme(QStringLiteral("application-exit")), i18n("Send SIGTERM"))->setData(15);
43​ addAction(QStringLiteral("SIGKILL"), QIcon::fromTheme(QStringLiteral("process-stop")), i18n("Send SIGKILL"))->setData(9);
44​ m_actionList = {action(QStringLiteral("SIGTERM")), action(QStringLiteral("SIGKILL"))};
44 45​
45 connect(this, &Plasma::AbstractRunner::prepare, this, &KillRunner::prep); 46​ connect(this, &Plasma::AbstractRunner::prepare, this, &KillRunner::prep);
46 connect(this, &Plasma::AbstractRunner::teardown, this, &KillRunner::cleanup); 47​ connect(this, &Plasma::AbstractRunner::teardown, this, &KillRunner::cleanup);
47 48​
48 m_delayedCleanupTimer.setInterval(50); 49​ m_delayedCleanupTimer.setInterval(50);
49 m_delayedCleanupTimer.setSingleShot(true); 50​ m_delayedCleanupTimer.setSingleShot(true);
50 connect(&m_delayedCleanupTimer, &QTimer::timeout, this, &KillRunner::cleanup); 51​ connect(&m_delayedCleanupTimer, &QTimer::timeout, this, &KillRunner::cleanup);
51} 52​}
52 53​
53KillRunner::~KillRunner() 54​KillRunner::~KillRunner()
54{ 55​{
55} 56​}
56 57​
57 58​
58void KillRunner::reloadConfiguration() 59​void KillRunner::reloadConfiguration()
59{ 60​{
60 KConfigGroup grp = config(); 61​ const KConfigGroup grp = config();
61 m_triggerWord.clear(); 62​ m_triggerWord.clear();
62 if (grp.readEntry(CONFIG_USE_TRIGGERWORD, true)) { 63​ if (grp.readEntry(CONFIG_USE_TRIGGERWORD, true)) {
63 m_triggerWord = grp.readEntry(CONFIG_TRIGGERWORD, i18n("kill")) + QLatin1Char(' '); 64​ m_triggerWord = grp.readEntry(CONFIG_TRIGGERWORD, i18n("kill")) + QLatin1Char(' ');
64 } 65​ }
66​ m_hasTrigger = !m_triggerWord.isEmpty();
65 67​
66 m_sorting = (KillRunnerConfig::Sort) grp.readEntry(CONFIG_SORTING, 0); 68​ m_sorting = (Sort) grp.readEntry(CONFIG_SORTING, 0);
67 QList<Plasma::RunnerSyntax> syntaxes; 69​ QList<Plasma::RunnerSyntax> syntaxes;
68 syntaxes << Plasma::RunnerSyntax(m_triggerWord + QStringLiteral(":q:"), 70​ syntaxes << Plasma::RunnerSyntax(m_triggerWord + QStringLiteral(":q:"),
69 i18n("Terminate running applications whose names match the query.")); 71​ i18n("Terminate running applications whose names match the query."));
70 setSyntaxes(syntaxes); 72​ setSyntaxes(syntaxes);
71} 73​}
72 74​
73void KillRunner::prep() 75​void KillRunner::prep()
74{ 76​{
Show All 14 Lines81{
89 } else { 91​ } else {
90 m_delayedCleanupTimer.stop(); 92​ m_delayedCleanupTimer.stop();
91 } 93​ }
92} 94​}
93 95​
94void KillRunner::match(Plasma::RunnerContext &context) 96​void KillRunner::match(Plasma::RunnerContext &context)
95{ 97​{
96 QString term = context.query(); 98​ QString term = context.query();
97 const bool hasTrigger = !m_triggerWord.isEmpty(); 99​ if (m_hasTrigger && !term.startsWith(m_triggerWord, Qt::CaseInsensitive)) {
98 if (hasTrigger && !term.startsWith(m_triggerWord, Qt::CaseInsensitive)) { ​
99 return; 100​ return;
100 } 101​ }
101 102​
102 m_prepLock.lockForRead(); 103​ m_prepLock.lockForRead();
103 if (!m_processes) { 104​ if (!m_processes) {
104 m_prepLock.unlock(); 105​ m_prepLock.unlock();
105 m_prepLock.lockForWrite(); 106​ m_prepLock.lockForWrite();
106 if (!m_processes) { 107​ if (!m_processes) {
107 suspendMatching(true); 108​ suspendMatching(true);
108 m_processes = new KSysGuard::Processes(); 109​ m_processes = new KSysGuard::Processes();
109 m_processes->updateAllProcesses(); 110​ m_processes->updateAllProcesses();
110 suspendMatching(false); 111​ suspendMatching(false);
111 } 112​ }
112 } 113​ }
113 m_prepLock.unlock(); 114​ m_prepLock.unlock();
114 115​
115 term = term.right(term.length() - m_triggerWord.length()); 116​ term = term.right(term.length() - m_triggerWord.length());
116 117​
117 if (term.length() < 2) { 118​ if (term.length() < 2 || !context.isValid()) {
118 return; 119​ return;
119 } 120​ }
120 121​
121 QList<Plasma::QueryMatch> matches; 122​ QList<Plasma::QueryMatch> matches;
122 const QList<KSysGuard::Process *> processlist = m_processes->getAllProcesses(); 123​ const QList<KSysGuard::Process *> processlist = m_processes->getAllProcesses();
123 for (const KSysGuard::Process *process : processlist) { 124​ for (const KSysGuard::Process *process : processlist) {
124 if (!context.isValid()) { ​
125 return; ​
126 } ​
127 ​
128 const QString name = process->name(); 125​ const QString name = process->name();
129 if (!name.contains(term, Qt::CaseInsensitive)) { 126​ if (!name.contains(term, Qt::CaseInsensitive)) {
130 //Process doesn't match the search term ​
131 continue; 127​ continue;
132 } 128​ }
133 129​
134 const quint64 pid = process->pid(); 130​ const quint64 pid = process->pid();
135 const qlonglong uid = process->uid(); ​
136 const QString user = getUserName(uid); ​
137 ​
138 QVariantList data; ​
139 data << pid << user; ​
140 131​
141 Plasma::QueryMatch match(this); 132​ Plasma::QueryMatch match(this);
142 match.setText(i18n("Terminate %1", name)); 133​ match.setText(i18n("Terminate %1", name));
143 match.setSubtext(i18n("Process ID: %1\nRunning as user: %2", QString::number(pid), user)); 134​ match.setSubtext(i18n("Process ID: %1", QString::number(pid)));
144 match.setIconName(QStringLiteral("application-exit")); 135​ match.setIconName(QStringLiteral("application-exit"));
145 match.setData(data); 136​ match.setData(pid);
146 match.setId(name); 137​ match.setId(name);
147 138​
148 // Set the relevance 139​ // Set the relevance
149 switch (m_sorting) { 140​ switch (m_sorting) {
150 case KillRunnerConfig::CPU: 141​ case CPU:
151 match.setRelevance((process->userUsage() + process->sysUsage()) / 100); 142​ match.setRelevance((process->userUsage() + process->sysUsage()) / 100);
152 break; 143​ break;
153 case KillRunnerConfig::CPUI: 144​ case CPUI:
154 match.setRelevance(1 - (process->userUsage() + process->sysUsage()) / 100); 145​ match.setRelevance(1 - (process->userUsage() + process->sysUsage()) / 100);
155 break; 146​ break;
156 case KillRunnerConfig::NONE: 147​ case NONE:
157 match.setRelevance(name.compare(term, Qt::CaseInsensitive) == 0 ? 1 : 9); 148​ match.setRelevance(name.compare(term, Qt::CaseInsensitive) == 0 ? 1 : 9);
158 break; 149​ break;
159 } 150​ }
160 151​
161 matches << match; 152​ matches << match;
162 } 153​ }
163 154​
164 qDebug() << "match count is" << matches.count(); ​
165 context.addMatches(matches); 155​ context.addMatches(matches);
166} 156​}
167 157​
168void KillRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match) 158​void KillRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match)
169{ 159​{
170 Q_UNUSED(context) 160​ Q_UNUSED(context)
171 161​
172 QVariantList data = match.data().value<QVariantList>(); 162​ quint64 pid = match.data().toUInt();
173 quint64 pid = data[0].toUInt(); ​
174// QString user = data[1].toString(); ​
175 163​
176 int signal; 164​ int signal;
177 if (match.selectedAction() != nullptr) { 165​ if (match.selectedAction()) {
178 signal = match.selectedAction()->data().toInt(); 166​ signal = match.selectedAction()->data().toInt();
179 } else { 167​ } else {
180 signal = 9; //default: SIGKILL 168​ signal = 9; //default: SIGKILL
181 } 169​ }
182 170​
183 QStringList args; 171​ QStringList args = {QStringLiteral("-%1").arg(signal), QStringLiteral("%1").arg(pid)};
184 args << QStringLiteral("-%1").arg(signal) << QStringLiteral("%1").arg(pid); 172​ int returnCode = KProcess::execute(QStringLiteral("kill"), args);
185 KProcess process; 173​ if (returnCode == 0) {
186 int returnCode = process.execute(QStringLiteral("kill"), args); ​
187 ​
188 if (returnCode == 0) ​
189 { ​
190 return; 174​ return;
191 } 175​ }
192 176​
193 KAuth::Action killAction = QStringLiteral("org.kde.ksysguard.processlisthelper.sendsignal"); 177​ KAuth::Action killAction = QStringLiteral("org.kde.ksysguard.processlisthelper.sendsignal");
194 killAction.setHelperId(QStringLiteral("org.kde.ksysguard.processlisthelper")); 178​ killAction.setHelperId(QStringLiteral("org.kde.ksysguard.processlisthelper"));
195 killAction.addArgument(QStringLiteral("pid0"), pid); 179​ killAction.addArgument(QStringLiteral("pid0"), pid);
196 killAction.addArgument(QStringLiteral("pidcount"), 1); 180​ killAction.addArgument(QStringLiteral("pidcount"), 1);
197 killAction.addArgument(QStringLiteral("signal"), signal); 181​ killAction.addArgument(QStringLiteral("signal"), signal);
198 killAction.execute(); 182​ killAction.execute();
199} 183​}
200 184​
201QList<QAction*> KillRunner::actionsForMatch(const Plasma::QueryMatch &match) 185​QList<QAction*> KillRunner::actionsForMatch(const Plasma::QueryMatch &match)
202{ 186​{
203 Q_UNUSED(match) 187​ Q_UNUSED(match)
204 188​
205 QList<QAction*> ret; 189​ return m_actionList;
206 ​
207 if (!action(QStringLiteral("SIGTERM"))) { ​
208 (addAction(QStringLiteral("SIGTERM"), QIcon::fromTheme(QStringLiteral("application-exit")), i18n("Send SIGTERM")))->setData(15); ​
209 (addAction(QStringLiteral("SIGKILL"), QIcon::fromTheme(QStringLiteral("process-stop")), i18n("Send SIGKILL")))->setData(9); ​
210 } ​
211 ret << action(QStringLiteral("SIGTERM")) << action(QStringLiteral("SIGKILL")); ​
212 return ret; ​
213} ​
214 ​
215QString KillRunner::getUserName(qlonglong uid) ​
216{ ​
217 KUser user(uid); ​
218 if (user.isValid()) { ​
219 return user.loginName(); ​
220 } ​
221 qDebug() << QStringLiteral("No user with UID %1 was found").arg(uid); ​
222 return QStringLiteral("root");//No user with UID uid was found, so root is used ​
223} 190​}
224 191​
225#include "killrunner.moc" 192​#include "killrunner.moc"