workspace/libs/plasma/abstractrunner.cpp

   1 /*
   2  *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License as
   6  *   published by the Free Software Foundation; either version 2, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details
  13  *
  14  *   You should have received a copy of the GNU Library General Public
  15  *   License along with this program; if not, write to the
  16  *   Free Software Foundation, Inc.,
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "abstractrunner.h"
  21
  22 #include <QMutex>
  23 #include <QMutexLocker>
  24
  25 #include <KDebug>
  26 #include <KPluginInfo>
  27 #include <KServiceTypeTrader>
  28 #include <QTimer>
  29
  30 #include "scripting/runnerscript.h"
  31 #include "searchcontext.h"
  32
  33 namespace Plasma
  34 {
  35
  36 class AbstractRunner::Private
  37 {
  38     public:
  39         bool hasMatchOptions;
  40         bool hasConfig;
  41         Priority priority;
  42         Speed speed;
  43         RunnerScript* script;
  44         KPluginInfo runnerDescription;
  45         AbstractRunner* runner;
  46         QTime runtime;
  47         int fastRuns;
  48
  49     Private(AbstractRunner* r, KService::Ptr service)
  50       : priority(NormalPriority),
  51         speed(NormalSpeed),
  52         script(0),
  53         runnerDescription(service),
  54         runner(r),
  55         fastRuns(0)
  56     {
  57         if (runnerDescription.isValid()) {
  58             QString language = runnerDescription.property("X-Plasma-Language").toString();
  59
  60             if (!language.isEmpty()) {
  61                 script = Plasma::loadScriptEngine(language, runner);
  62                 if (!script) {
  63                     kDebug() << "Could not create a" << language << "ScriptEngine for the"
  64                     << runnerDescription.name() << "Runner.";
  65                 } else {
  66                     QTimer::singleShot(0, runner, SLOT(init()));
  67                 }
  68             }
  69         }
  70     }
  71
  72     static QMutex bigLock;
  73 };
  74
  75 QMutex AbstractRunner::Private::bigLock;
  76
  77 AbstractRunner::AbstractRunner(QObject* parent, const QString& serviceId)
  78     : QObject(parent),
  79       d(new Private(this, KService::serviceByStorageId(serviceId)))
  80 {
  81 }
  82
  83 AbstractRunner::AbstractRunner(QObject* parent, const QVariantList& args)
  84     : QObject(parent),
  85       d(new Private(this, KService::serviceByStorageId(args.count() > 0 ? args[0].toString() : QString())))
  86 {
  87 }
  88
  89 AbstractRunner::~AbstractRunner()
  90 {
  91     delete d;
  92 }
  93
  94 KConfigGroup AbstractRunner::config() const
  95 {
  96     QString group = objectName();
  97     if (group.isEmpty()) {
  98         group = "UnnamedRunner";
  99     }
 100
 101     KConfigGroup runners(KGlobal::config(), "Runners");
 102     return KConfigGroup(&runners, group);
 103 }
 104
 105 void AbstractRunner::performMatch( Plasma::SearchContext &globalContext )
 106 {
 107     static const int reasonableRunTime = 1500;
 108     static const int fastEnoughTime = 250;
 109
 110     d->runtime.restart();
 111     SearchContext localContext(0, globalContext);
 112
 113     match(&localContext);
 114
 115     // automatically rate limit runners that become slooow
 116     const int runtime = d->runtime.elapsed();
 117     bool slowed = speed() == SlowSpeed;
 118
 119     if (!slowed && runtime > reasonableRunTime) {
 120         // we punish runners that return too slowly, even if they don't bring
 121         // back matches
 122         kDebug() << runnerName() << "runner is too slow, putting it on the back burner.";
 123         d->fastRuns = 0;
 124         setSpeed(SlowSpeed);
 125     }
 126
 127     //If matches were not added, delete items on the heap
 128     if (localContext.addMatchesTo(globalContext) &&
 129         slowed && runtime < fastEnoughTime) {
 130         ++d->fastRuns;
 131
 132         if (d->fastRuns > 2) {
 133             // we reward slowed runners who bring back matches fast enough
 134             // 3 times in a row
 135             kDebug() << runnerName() << "runner is faster than we thought, kicking it up a notch";
 136             setSpeed(NormalSpeed);
 137         }
 138     }
 139 }
 140
 141 bool AbstractRunner::hasMatchOptions()
 142 {
 143     return d->hasMatchOptions;
 144 }
 145
 146 void AbstractRunner::setHasMatchOptions(bool hasMatchOptions)
 147 {
 148     d->hasMatchOptions = hasMatchOptions;
 149 }
 150
 151 void AbstractRunner::createMatchOptions(QWidget *parent)
 152 {
 153     Q_UNUSED(parent)
 154 }
 155
 156 bool AbstractRunner::isConfigurable()
 157 {
 158     return d->hasConfig;
 159 }
 160
 161 void AbstractRunner::setIsConfigurable(bool hasConfig)
 162 {
 163     d->hasConfig = hasConfig;
 164 }
 165
 166 void AbstractRunner::createConfigurationInterface(QWidget *widget)
 167 {
 168     Q_UNUSED(widget)
 169 }
 170
 171 AbstractRunner::Speed AbstractRunner::speed() const
 172 {
 173     return d->speed;
 174 }
 175
 176 void AbstractRunner::setSpeed(Speed speed)
 177 {
 178     d->speed = speed;
 179 }
 180
 181 AbstractRunner::Priority AbstractRunner::priority() const
 182 {
 183     return d->priority;
 184 }
 185
 186 void AbstractRunner::setPriority(Priority priority)
 187 {
 188     d->priority = priority;
 189 }
 190
 191 KService::List AbstractRunner::serviceQuery(const QString &serviceType, const QString &constraint) const
 192 {
 193     QMutexLocker lock(&Private::bigLock);
 194     return KServiceTypeTrader::self()->query(serviceType, constraint);
 195 }
 196
 197 QMutex* AbstractRunner::bigLock() const
 198 {
 199     return &Private::bigLock;
 200 }
 201
 202 void AbstractRunner::exec(const Plasma::SearchContext *search, const Plasma::SearchMatch *action)
 203 {
 204     if (d->script) {
 205         return d->script->exec(search, action);
 206     }
 207 }
 208
 209 void AbstractRunner::match(Plasma::SearchContext *search)
 210 {
 211     if (d->script) {
 212         return d->script->match(search);
 213     }
 214 }
 215
 216 QString AbstractRunner::runnerName() const
 217 {
 218     if (!d->runnerDescription.isValid()) {
 219         return objectName();
 220     }
 221     return d->runnerDescription.property("X-Plasma-RunnerName").toString();
 222 }
 223
 224 void AbstractRunner::init()
 225 {
 226     if (d->script) {
 227         d->script->init();
 228     }
 229 }
 230
 231 AbstractRunner::List AbstractRunner::load(QObject* parent, const QStringList& whitelist)
 232 {
 233     List firstRunners;
 234     List runners;
 235     List lastRunners;
 236
 237     KService::List offers = KServiceTypeTrader::self()->query("Plasma/Runner");
 238     QString error;
 239     foreach (KService::Ptr service, offers) {
 240         if (whitelist.empty() || whitelist.contains(service->name())) {
 241             QString language = service->property("X-Plasma-Language").toString();
 242             AbstractRunner* runner = 0;
 243
 244             if (language.isEmpty()) {
 245                 QVariantList args;
 246                 args << service->storageId();
 247                 runner = service->createInstance<AbstractRunner>(parent, args, &error);
 248             } else {
 249                 runner = new AbstractRunner(parent, service->storageId());
 250             }
 251
 252             if (runner) {
 253                 //kDebug() << "loaded runner : " << service->name();
 254                 QString phase = service->property("X-Plasma-RunnerPhase").toString();
 255                 if (phase == "last") {
 256                     lastRunners.append(runner);
 257                 } else if (phase == "first") {
 258                     firstRunners.append(runner);
 259                 } else {
 260                     runners.append(runner);
 261                 }
 262             } else {
 263                 kDebug() << "failed to load runner : " << service->name() << ". error reported: " << error;
 264             }
 265         }
 266     }
 267
 268     firstRunners << runners << lastRunners;
 269     return firstRunners;
 270 }
 271
 272 } // Plasma namespace
 273
 274 #include "abstractrunner.moc"