Differential D27513 Diff 76022 runners/kill/killrunner.cpp

Changeset View

Standalone View

View Options

runners/kill/killrunner.cpp

Show All 19 Lines
20#include "killrunner.h" 20​#include "killrunner.h"
21 21​
22#include <QAction> 22​#include <QAction>
23#include <QDebug> 23​#include <QDebug>
24#include <QIcon> 24​#include <QIcon>
25 25​
26#include <KProcess> 26​#include <KProcess>
27#include <KUser> 27​#include <KUser>
28#include <kauth.h> 28​#include <KLocalizedString>
29​#include <KAuth>
29 30​
30#include "processcore/processes.h" 31​#include <processcore/processes.h>
31#include "processcore/process.h" 32​#include <processcore/process.h>
32 ​
33#include "killrunner_config.h" ​
34 33​
35K_EXPORT_PLASMA_RUNNER(kill, KillRunner) 34​K_EXPORT_PLASMA_RUNNER(kill, KillRunner)
36 35​
37KillRunner::KillRunner(QObject *parent, const QVariantList& args) 36​KillRunner::KillRunner(QObject *parent, const QVariantList& args)
38 : Plasma::AbstractRunner(parent, args), 37​ : Plasma::AbstractRunner(parent, args), m_processes(nullptr)
39 m_processes(nullptr) ​
40{ 38​{
41 Q_UNUSED(args); 39​ setObjectName(QStringLiteral("Kill Runner"));
42 setObjectName( QLatin1String("Kill Runner") ); 40​
43 reloadConfiguration(); 41​ addAction(QStringLiteral("SIGTERM"), QIcon::fromTheme(QStringLiteral("application-exit")), i18n("Send SIGTERM"))->setData(15);
42​ addAction(QStringLiteral("SIGKILL"), QIcon::fromTheme(QStringLiteral("process-stop")), i18n("Send SIGKILL"))->setData(9);
43​ m_actionList = {action(QStringLiteral("SIGTERM")), action(QStringLiteral("SIGKILL"))};
44 44​
45 connect(this, &Plasma::AbstractRunner::prepare, this, &KillRunner::prep); 45​ connect(this, &Plasma::AbstractRunner::prepare, this, &KillRunner::prep);
46 connect(this, &Plasma::AbstractRunner::teardown, this, &KillRunner::cleanup); 46​ connect(this, &Plasma::AbstractRunner::teardown, this, &KillRunner::cleanup);
47 47​
48 m_delayedCleanupTimer.setInterval(50); 48​ m_delayedCleanupTimer.setInterval(50);
49 m_delayedCleanupTimer.setSingleShot(true); 49​ m_delayedCleanupTimer.setSingleShot(true);
50 connect(&m_delayedCleanupTimer, &QTimer::timeout, this, &KillRunner::cleanup); 50​ connect(&m_delayedCleanupTimer, &QTimer::timeout, this, &KillRunner::cleanup);
51} 51​}
52 52​
53KillRunner::~KillRunner() 53​KillRunner::~KillRunner()
54{ 54​{
55} 55​}
56 56​
57 57​
58void KillRunner::reloadConfiguration() 58​void KillRunner::reloadConfiguration()
59{ 59​{
60 KConfigGroup grp = config(); 60​ const KConfigGroup grp = config();
61 m_triggerWord.clear(); 61​ m_triggerWord.clear();
62 if (grp.readEntry(CONFIG_USE_TRIGGERWORD, true)) { 62​ if (grp.readEntry(CONFIG_USE_TRIGGERWORD, true)) {
63 m_triggerWord = grp.readEntry(CONFIG_TRIGGERWORD, i18n("kill")) + QLatin1Char(' '); 63​ m_triggerWord = grp.readEntry(CONFIG_TRIGGERWORD, i18n("kill")) + QLatin1Char(' ');
64 } 64​ }
65​ m_hasTrigger = !m_triggerWord.isEmpty();
65 66​
66 m_sorting = (KillRunnerConfig::Sort) grp.readEntry(CONFIG_SORTING, 0); 67​ m_sorting = (Sort) grp.readEntry(CONFIG_SORTING, 0);
67 QList<Plasma::RunnerSyntax> syntaxes; 68​ QList<Plasma::RunnerSyntax> syntaxes;
68 syntaxes << Plasma::RunnerSyntax(m_triggerWord + QStringLiteral(":q:"), 69​ syntaxes << Plasma::RunnerSyntax(m_triggerWord + QStringLiteral(":q:"),
69 i18n("Terminate running applications whose names match the query.")); 70​ i18n("Terminate running applications whose names match the query."));
70 setSyntaxes(syntaxes); 71​ setSyntaxes(syntaxes);
71} 72​}
72 73​
73void KillRunner::prep() 74​void KillRunner::prep()
74{ 75​{
Show All 14 Lines80{
89 } else { 90​ } else {
90 m_delayedCleanupTimer.stop(); 91​ m_delayedCleanupTimer.stop();
91 } 92​ }
92} 93​}
93 94​
94void KillRunner::match(Plasma::RunnerContext &context) 95​void KillRunner::match(Plasma::RunnerContext &context)
95{ 96​{
96 QString term = context.query(); 97​ QString term = context.query();
97 const bool hasTrigger = !m_triggerWord.isEmpty(); 98​ if (m_hasTrigger && !term.startsWith(m_triggerWord, Qt::CaseInsensitive)) {
98 if (hasTrigger && !term.startsWith(m_triggerWord, Qt::CaseInsensitive)) { ​
99 return; 99​ return;
100 } 100​ }
101 101​
102 m_prepLock.lockForRead(); 102​ m_prepLock.lockForRead();
103 if (!m_processes) { 103​ if (!m_processes) {
104 m_prepLock.unlock(); 104​ m_prepLock.unlock();
105 m_prepLock.lockForWrite(); 105​ m_prepLock.lockForWrite();
106 if (!m_processes) { 106​ if (!m_processes) {
107 suspendMatching(true); 107​ suspendMatching(true);
108 m_processes = new KSysGuard::Processes(); 108​ m_processes = new KSysGuard::Processes();
109 m_processes->updateAllProcesses(); 109​ m_processes->updateAllProcesses();
110 suspendMatching(false); 110​ suspendMatching(false);
111 } 111​ }
112 } 112​ }
113 m_prepLock.unlock(); 113​ m_prepLock.unlock();
114 114​
115 term = term.right(term.length() - m_triggerWord.length()); 115​ term = term.right(term.length() - m_triggerWord.length());
116 116​
117 if (term.length() < 2) { 117​ if (term.length() < 2 || !context.isValid()) {
118 return; 118​ return;
119 } 119​ }
120 120​
121 QList<Plasma::QueryMatch> matches; 121​ QList<Plasma::QueryMatch> matches;
122 const QList<KSysGuard::Process *> processlist = m_processes->getAllProcesses(); 122​ const QList<KSysGuard::Process *> processlist = m_processes->getAllProcesses();
123 for (const KSysGuard::Process *process : processlist) { 123​ for (const KSysGuard::Process *process : processlist) {
124 if (!context.isValid()) { ​
125 return; ​
126 } ​
127 ​
128 const QString name = process->name(); 124​ const QString name = process->name();
129 if (!name.contains(term, Qt::CaseInsensitive)) { 125​ if (!name.contains(term, Qt::CaseInsensitive)) {
130 //Process doesn't match the search term ​
131 continue; 126​ continue;
132 } 127​ }
133 128​
134 const quint64 pid = process->pid(); 129​ 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 130​
141 Plasma::QueryMatch match(this); 131​ Plasma::QueryMatch match(this);
142 match.setText(i18n("Terminate %1", name)); 132​ match.setText(i18n("Terminate %1", name));
143 match.setSubtext(i18n("Process ID: %1\nRunning as user: %2", QString::number(pid), user)); 133​ match.setSubtext(i18n("Process ID: %1", QString::number(pid)));
144 match.setIconName(QStringLiteral("application-exit")); 134​ match.setIconName(QStringLiteral("application-exit"));
145 match.setData(data); 135​ match.setData(pid);
146 match.setId(name); 136​ match.setId(name);
147 137​
148 // Set the relevance 138​ // Set the relevance
149 switch (m_sorting) { 139​ switch (m_sorting) {
150 case KillRunnerConfig::CPU: 140​ case CPU:
151 match.setRelevance((process->userUsage() + process->sysUsage()) / 100); 141​ match.setRelevance((process->userUsage() + process->sysUsage()) / 100);
152 break; 142​ break;
153 case KillRunnerConfig::CPUI: 143​ case CPUI:
154 match.setRelevance(1 - (process->userUsage() + process->sysUsage()) / 100); 144​ match.setRelevance(1 - (process->userUsage() + process->sysUsage()) / 100);
155 break; 145​ break;
156 case KillRunnerConfig::NONE: 146​ case NONE:
157 match.setRelevance(name.compare(term, Qt::CaseInsensitive) == 0 ? 1 : 9); 147​ match.setRelevance(name.compare(term, Qt::CaseInsensitive) == 0 ? 1 : 9);
158 break; 148​ break;
159 } 149​ }
160 150​
161 matches << match; 151​ matches << match;
162 } 152​ }
163 153​
164 qDebug() << "match count is" << matches.count(); ​
165 context.addMatches(matches); 154​ context.addMatches(matches);
166} 155​}
167 156​
168void KillRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match) 157​void KillRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match)
169{ 158​{
170 Q_UNUSED(context) 159​ Q_UNUSED(context)
171 160​
172 QVariantList data = match.data().value<QVariantList>(); 161​ quint64 pid = match.data().toUInt();
173 quint64 pid = data[0].toUInt(); ​
174// QString user = data[1].toString(); ​
175 162​
176 int signal; 163​ int signal;
177 if (match.selectedAction() != nullptr) { 164​ if (match.selectedAction()) {
178 signal = match.selectedAction()->data().toInt(); 165​ signal = match.selectedAction()->data().toInt();
179 } else { 166​ } else {
180 signal = 9; //default: SIGKILL 167​ signal = 9; //default: SIGKILL
181 } 168​ }
182 169​
183 QStringList args; 170​ QStringList args = {QStringLiteral("-%1").arg(signal), QStringLiteral("%1").arg(pid)};
184 args << QStringLiteral("-%1").arg(signal) << QStringLiteral("%1").arg(pid); 171​ int returnCode = KProcess::execute(QStringLiteral("kill"), args);
185 KProcess process; 172​ if (returnCode == 0) {
186 int returnCode = process.execute(QStringLiteral("kill"), args); ​
187 ​
188 if (returnCode == 0) ​
189 { ​
190 return; 173​ return;
191 } 174​ }
192 175​
193 KAuth::Action killAction = QStringLiteral("org.kde.ksysguard.processlisthelper.sendsignal"); 176​ KAuth::Action killAction = QStringLiteral("org.kde.ksysguard.processlisthelper.sendsignal");
194 killAction.setHelperId(QStringLiteral("org.kde.ksysguard.processlisthelper")); 177​ killAction.setHelperId(QStringLiteral("org.kde.ksysguard.processlisthelper"));
195 killAction.addArgument(QStringLiteral("pid0"), pid); 178​ killAction.addArgument(QStringLiteral("pid0"), pid);
196 killAction.addArgument(QStringLiteral("pidcount"), 1); 179​ killAction.addArgument(QStringLiteral("pidcount"), 1);
197 killAction.addArgument(QStringLiteral("signal"), signal); 180​ killAction.addArgument(QStringLiteral("signal"), signal);
198 killAction.execute(); 181​ killAction.execute();
199} 182​}
200 183​
201QList<QAction*> KillRunner::actionsForMatch(const Plasma::QueryMatch &match) 184​QList<QAction*> KillRunner::actionsForMatch(const Plasma::QueryMatch &match)
202{ 185​{
203 Q_UNUSED(match) 186​ Q_UNUSED(match)
204 187​
205 QList<QAction*> ret; 188​ 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} 189​}
224 190​
225#include "killrunner.moc" 191​#include "killrunner.moc"