akonadiconsole/jobtracker.cpp

   1 /*
   2  This file is part of Akonadi.
   3
   4  Copyright (c) 2009 Till Adam <adam@kde.org>
   5
   6  This program is free software; you can redistribute it and/or modify
   7  it under the terms of the GNU General Public License as published by
   8  the Free Software Foundation; either version 2 of the License, or
   9  (at your option) any later version.
  10
  11  This program is distributed in the hope that it will be useful,
  12  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  GNU General Public License for more details.
  15
  16  You should have received a copy of the GNU General Public License
  17  along with this program; if not, write to the Free Software
  18  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19  USA.
  20  */
  21
  22 #include "jobtracker.h"
  23 #include "jobtrackeradaptor.h"
  24
  25 #include <QtCore/QString>
  26 #include <QtCore/QStringList>
  27 #include <QtCore/QDebug>
  28
  29 #include <cassert>
  30
  31 QString JobInfo::stateAsString() const
  32 {
  33     switch( state )
  34     {
  35         case Initial:
  36             return QLatin1String("Initial");
  37         case Running:
  38             return QLatin1String("Running");
  39         case Ended:
  40             return QLatin1String("Ended");
  41         case Failed:
  42             return QString::fromLatin1( "Failed: %1" ).arg( error );
  43         default:
  44             return QLatin1String("Unknown state!");
  45     }
  46 }
  47
  48
  49 class JobTracker::Private
  50 {
  51 public:
  52   Private(JobTracker* _q)
  53   :q(_q), lastId(42), timer( _q )
  54   {
  55     timer.setSingleShot( true );
  56     timer.setInterval( 200 );
  57     connect( &timer, SIGNAL(timeout()), q, SIGNAL(updated()) );
  58   }
  59
  60   bool isSession( int id ) const
  61   {
  62     return id < -1;
  63   }
  64
  65   void emitUpdated()
  66   {
  67     if ( !timer.isActive() && !disabled )
  68       timer.start();
  69   }
  70
  71   QStringList sessions;
  72   QMap<QString, int> idToSequence;
  73   QMap<int, QString> sequenceToId;
  74   QMap<QString, QStringList> jobs;
  75   QMap<QString, JobInfo> infos;
  76   int lastId;
  77   QTimer timer;
  78   bool disabled;
  79 private:
  80   JobTracker* const q;
  81 };
  82
  83 JobTracker::JobTracker( const char *name, QObject* parent )
  84 :QObject( parent ), d( new Private( this ) )
  85 {
  86   new JobTrackerAdaptor( this );
  87   QDBusConnection::sessionBus().registerService( QLatin1String("org.kde.akonadiconsole") );
  88   QDBusConnection::sessionBus().registerObject( '/'+QLatin1String(name),
  89       this, QDBusConnection::ExportAdaptors );
  90
  91 #if 0
  92     // dummy data for testing
  93     d->sessions << "one" << "two" << "three";
  94     d->jobs.insert("one", QStringList() << "eins" );
  95     d->jobs.insert("two", QStringList() );
  96     d->jobs.insert("three", QStringList() );
  97
  98     // create some fake jobs
  99     d->jobs.insert( "eins", QStringList() << "sub-eins" << "sub-zwei" );
 100     d->idToSequence.insert( "eins", 0 );
 101     d->sequenceToId.insert( 0, "eins" );
 102     JobInfo info;
 103     info.id = "eins";
 104     info.parent = -2;
 105     d->infos.insert( "eins", info );
 106
 107     d->jobs.insert( "sub-eins", QStringList() );
 108     d->idToSequence.insert( "sub-eins", 1 );
 109     d->sequenceToId.insert( 1, "sub-eins" );
 110     info.id = "sub-eins";
 111     info.parent = 0;
 112     d->infos.insert( "sub-eins", info );
 113
 114     d->jobs.insert( "sub-zwei", QStringList() );
 115     d->idToSequence.insert( "sub-zwei", 2 );
 116     d->sequenceToId.insert( 2, "sub-zwei" );
 117     info.id = "sub-zwei";
 118     info.parent = 0;
 119     d->infos.insert( "sub-zwei", info );
 120 #endif
 121 }
 122
 123 JobTracker::~JobTracker()
 124 {
 125   delete d;
 126 }
 127
 128 void JobTracker::jobCreated( const QString & session, const QString & job, const QString & parent, const QString & jobType )
 129 {
 130   if ( d->disabled || session.isEmpty() || job.isEmpty() ) return;
 131
 132   if ( !parent.isEmpty() && !d->jobs.contains( parent ) )
 133   {
 134     qWarning() << "JobTracker: Job arrived before it's parent! Fix the library!";
 135     jobCreated( session, parent, QString(),"dummy job type" );
 136   }
 137
 138   // check if it's a new session, if so, add it
 139   if (!d->sessions.contains( session ) )
 140   {
 141     d->sessions.append( session );
 142     d->jobs.insert( session, QStringList() );
 143   }
 144
 145   // deal with the job
 146   if ( d->jobs.contains( job ) ) return; // duplicate?
 147
 148   d->jobs.insert( job, QStringList() );
 149
 150   JobInfo info;
 151   info.id = job;
 152   if ( parent.isEmpty() )
 153     info.parent = idForSession( session );
 154   else
 155     info.parent = idForJob( parent );
 156   info.state = JobInfo::Initial;
 157   info.timestamp = QDateTime::currentDateTime();
 158   info.type = jobType;
 159   d->infos.insert( job, info );
 160   const int id = d->lastId++;
 161   d->idToSequence.insert( job, id );
 162   d->sequenceToId.insert( id, job );
 163
 164   QString daddy;
 165   if ( parent.isEmpty() )
 166     daddy = session;
 167   else
 168     daddy = parent;
 169
 170   assert(!daddy.isEmpty());
 171   QStringList kids = d->jobs[daddy];
 172   kids << job;
 173   d->jobs[daddy] = kids;
 174
 175   d->emitUpdated();
 176 }
 177
 178 void JobTracker::jobEnded( const QString& job, const QString& error )
 179 {
 180   // this is called from dbus, so better be defensive
 181   if ( d->disabled || !d->jobs.contains( job ) || !d->infos.contains( job ) ) return;
 182
 183   JobInfo info = d->infos[job];
 184   if ( error.isEmpty() ) {
 185     info.state = JobInfo::Ended;
 186   } else {
 187     info.state = JobInfo::Failed;
 188     info.error = error;
 189   }
 190   d->infos[job] = info;
 191
 192   d->emitUpdated();
 193 }
 194
 195 void JobTracker::jobStarted( const QString & job )
 196 {
 197   // this is called from dbus, so better be defensive
 198   if ( d->disabled || !d->jobs.contains( job ) || !d->infos.contains( job ) ) return;
 199
 200   JobInfo info = d->infos[job];
 201   info.state = JobInfo::Running;
 202   d->infos[job] = info;
 203
 204   d->emitUpdated();
 205 }
 206
 207 QStringList JobTracker::sessions() const
 208 {
 209   return d->sessions;
 210 }
 211
 212 QList<JobInfo> JobTracker::jobs( int id ) const
 213 {
 214   if ( d->isSession( id ) )
 215     return jobs( sessionForId( id ) );
 216   return jobs( jobForId( id ) );
 217 }
 218
 219 QList<JobInfo> JobTracker::jobs( const QString & parent ) const
 220 {
 221   assert( d->jobs.contains(parent) );
 222   const QStringList jobs = d->jobs[parent];
 223   QList<JobInfo> infos;
 224   Q_FOREACH( QString job, jobs )
 225   {
 226     infos << d->infos[job];
 227   }
 228   return infos;
 229 }
 230
 231 // only works on jobs
 232 int JobTracker::idForJob(const QString & job) const
 233 {
 234   assert( d->idToSequence.contains(job) );
 235   return d->idToSequence[job];
 236 }
 237
 238
 239
 240 QString JobTracker::jobForId(int id) const
 241 {
 242   if ( d->isSession( id ) )
 243     return sessionForId( id );
 244   assert( d->sequenceToId.contains(id) );
 245   return d->sequenceToId[id];
 246 }
 247
 248
 249 // To find a session, we take the offset in the list of sessions
 250 // in order of appearance, add one, and make it negative. That
 251 // way we can discern session ids from job ids and use -1 for invalid
 252 int JobTracker::idForSession(const QString & session) const
 253 {
 254   assert( d->sessions.contains( session ) );
 255   return ( d->sessions.indexOf(session) + 2 ) * -1;
 256 }
 257
 258 QString JobTracker::sessionForId(int _id) const
 259 {
 260   const int id = (-_id)-2;
 261   assert( d->sessions.size() > id );
 262   return d->sessions.at(id);
 263 }
 264
 265 int JobTracker::parentId( int id ) const
 266 {
 267   if ( d->isSession( id ) )
 268   {
 269     return -1;
 270   }
 271   else
 272   {
 273     const QString job = d->sequenceToId[id];
 274     return d->infos[job].parent;
 275   }
 276
 277 }
 278
 279 JobInfo JobTracker::info( int id) const
 280 {
 281   return info( jobForId( id ) );
 282 }
 283
 284 JobInfo JobTracker::info(const QString & job) const
 285 {
 286   assert( d->infos.contains(job) );
 287   return d->infos[job];
 288 }
 289
 290 void JobTracker::reset()
 291 {
 292   d->sessions.clear();
 293   d->idToSequence.clear();
 294   d->sequenceToId.clear();
 295   d->jobs.clear();
 296   d->infos.clear();
 297
 298   emit updated();
 299 }
 300
 301 void JobTracker::setEnabled( bool on )
 302 {
 303   d->disabled = !on;
 304 }
 305
 306 bool JobTracker::isEnabled() const
 307 {
 308   return !d->disabled;
 309 }
 310
 311 #include "jobtracker.moc"