runtime/nepomuk/server/servicecontroller.cpp

   1 /* This file is part of the KDE Project
   2    Copyright (c) 2008 Sebastian Trueg <trueg@kde.org>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public
   6    License version 2 as published by the Free Software Foundation.
   7
   8    This library is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11    Library General Public License for more details.
  12
  13    You should have received a copy of the GNU Library General Public License
  14    along with this library; see the file COPYING.LIB.  If not, write to
  15    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16    Boston, MA 02110-1301, USA.
  17 */
  18
  19 #include "servicecontroller.h"
  20 #include "processcontrol.h"
  21 #include "servicecontrolinterface.h"
  22 #include "nepomukserver.h"
  23
  24 #include <QtCore/QEventLoop>
  25 #include <QtCore/QTimer>
  26
  27 #include <KStandardDirs>
  28 #include <KConfigGroup>
  29 #include <KDebug>
  30
  31
  32 namespace {
  33     QString dbusServiceName( const QString& serviceName ) {
  34         return QString("org.kde.nepomuk.services.%1").arg(serviceName);
  35     }
  36 }
  37
  38
  39 class Nepomuk::ServiceController::Private
  40 {
  41 public:
  42     Private()
  43         : processControl( 0 ),
  44           serviceControlInterface( 0 ),
  45           attached( false ),
  46           initialized( false ),
  47           failedToInitialize( false ) {
  48     }
  49
  50     KService::Ptr service;
  51     bool autostart;
  52     bool startOnDemand;
  53     bool runOnce;
  54
  55     ProcessControl* processControl;
  56     OrgKdeNepomukServiceControlInterface* serviceControlInterface;
  57
  58     // true if we attached to an already running instance instead of
  59     // starting our own (in that case processControl will be 0)
  60     bool attached;
  61
  62     bool initialized;
  63     bool failedToInitialize;
  64
  65     // list of loops waiting for the service to become initialized
  66     QList<QEventLoop*> loops;
  67
  68     void init( KService::Ptr service );
  69 };
  70
  71
  72 void Nepomuk::ServiceController::Private::init( KService::Ptr s )
  73 {
  74     service = s;
  75     autostart = service->property( "X-KDE-Nepomuk-autostart", QVariant::Bool ).toBool();
  76     KConfigGroup cg( Server::self()->config(), QString("Service-%1").arg(service->desktopEntryName()) );
  77     autostart = cg.readEntry( "autostart", autostart );
  78
  79     QVariant p = service->property( "X-KDE-Nepomuk-start-on-demand", QVariant::Bool );
  80     startOnDemand = ( p.isValid() ? p.toBool() : false );
  81
  82     p = service->property( "X-KDE-Nepomuk-run-once", QVariant::Bool );
  83     runOnce = ( p.isValid() ? p.toBool() : false );
  84
  85     initialized = false;
  86 }
  87
  88
  89 Nepomuk::ServiceController::ServiceController( KService::Ptr service, QObject* parent )
  90     : QObject( parent ),
  91       d(new Private())
  92 {
  93     d->init( service );
  94 }
  95
  96
  97 Nepomuk::ServiceController::~ServiceController()
  98 {
  99     stop();
 100     delete d;
 101 }
 102
 103
 104 KService::Ptr Nepomuk::ServiceController::service() const
 105 {
 106     return d->service;
 107 }
 108
 109
 110 QString Nepomuk::ServiceController::name() const
 111 {
 112     return d->service->desktopEntryName();
 113 }
 114
 115
 116 QStringList Nepomuk::ServiceController::dependencies() const
 117 {
 118     QStringList deps = d->service->property( "X-KDE-Nepomuk-dependencies", QVariant::StringList ).toStringList();
 119     if ( deps.isEmpty() ) {
 120         deps.append( "nepomukstorage" );
 121     }
 122     deps.removeAll( name() );
 123     return deps;
 124 }
 125
 126
 127 void Nepomuk::ServiceController::setAutostart( bool enable )
 128 {
 129     KConfigGroup cg( Server::self()->config(), QString("Service-%1").arg(name()) );
 130     cg.writeEntry( "autostart", enable );
 131 }
 132
 133
 134 bool Nepomuk::ServiceController::autostart() const
 135 {
 136     return d->autostart;
 137 }
 138
 139
 140 bool Nepomuk::ServiceController::startOnDemand() const
 141 {
 142     return d->startOnDemand;
 143 }
 144
 145
 146 bool Nepomuk::ServiceController::runOnce() const
 147 {
 148     return d->runOnce;
 149 }
 150
 151
 152 bool Nepomuk::ServiceController::start()
 153 {
 154     if( isRunning() ) {
 155         return true;
 156     }
 157
 158     d->initialized = false;
 159     d->failedToInitialize = false;
 160
 161     // check if the service is already running, ie. has been started by someone else or by a crashed instance of the server
 162     // we cannot rely on the auto-restart feature of ProcessControl here. So we handle that completely in slotServiceOwnerChanged
 163     if( QDBusConnection::sessionBus().interface()->isServiceRegistered( dbusServiceName( name() ) ) ) {
 164         kDebug() << "Attaching to already running service" << name();
 165         d->attached = true;
 166         createServiceControlInterface();
 167         return true;
 168     }
 169     else {
 170         kDebug(300002) << "Starting" << name();
 171
 172         if( !d->processControl ) {
 173             d->processControl = new ProcessControl( this );
 174             connect( d->processControl, SIGNAL( finished( bool ) ),
 175                      this, SLOT( slotProcessFinished( bool ) ) );
 176         }
 177
 178         connect( QDBusConnection::sessionBus().interface(),
 179                  SIGNAL( serviceOwnerChanged( const QString&, const QString&, const QString& ) ),
 180                  this,
 181                  SLOT( slotServiceOwnerChanged( const QString&, const QString&, const QString& ) ) );
 182
 183         d->processControl->setCrashPolicy( ProcessControl::RestartOnCrash );
 184         return d->processControl->start( KGlobal::dirs()->locate( "exe", "nepomukservicestub" ),
 185                                          QStringList() << name() );
 186     }
 187 }
 188
 189
 190 void Nepomuk::ServiceController::stop()
 191 {
 192     if( isRunning() ) {
 193         kDebug(300002) << "Stopping" << name();
 194
 195         d->attached = false;
 196
 197         if( d->processControl ) {
 198             d->processControl->setCrashPolicy( ProcessControl::StopOnCrash );
 199         }
 200
 201         if ( d->serviceControlInterface ||
 202              ( !QCoreApplication::closingDown() &&
 203                waitForInitialized( 2000 ) ) ) {
 204             d->serviceControlInterface->shutdown();
 205         }
 206
 207         if( d->processControl ) {
 208             d->processControl->stop();
 209         }
 210
 211         // make sure all loops waiting for the service to initialize
 212         // are terminated.
 213         foreach( QEventLoop* loop, d->loops ) {
 214             loop->exit();
 215         }
 216     }
 217 }
 218
 219
 220 bool Nepomuk::ServiceController::isRunning() const
 221 {
 222     return( d->attached || ( d->processControl ? d->processControl->isRunning() : false ) );
 223 }
 224
 225
 226 bool Nepomuk::ServiceController::isInitialized() const
 227 {
 228     return d->initialized;
 229 }
 230
 231
 232 bool Nepomuk::ServiceController::waitForInitialized( int timeout )
 233 {
 234     if( !isRunning() ) {
 235         return false;
 236     }
 237
 238     if( !d->initialized && !d->failedToInitialize ) {
 239         QEventLoop loop;
 240         d->loops.append( &loop );
 241         if ( timeout > 0 ) {
 242             QTimer::singleShot( timeout, &loop, SLOT(quit()) );
 243         }
 244         QPointer<ServiceController> guard = this;
 245         loop.exec();
 246         if ( !guard.isNull() )
 247             d->loops.removeAll( &loop );
 248     }
 249
 250     return d->initialized;
 251 }
 252
 253
 254 void Nepomuk::ServiceController::slotProcessFinished( bool /*clean*/ )
 255 {
 256     kDebug() << "Service" << name() << "went down";
 257     d->initialized = false;
 258     d->attached = false;
 259     disconnect( QDBusConnection::sessionBus().interface() );
 260     delete d->serviceControlInterface;
 261     d->serviceControlInterface = 0;
 262     foreach( QEventLoop* loop, d->loops ) {
 263         loop->exit();
 264     }
 265 }
 266
 267
 268 void Nepomuk::ServiceController::slotServiceOwnerChanged( const QString& serviceName,
 269                                                           const QString& oldOwner,
 270                                                           const QString& newOwner )
 271 {
 272     if( !newOwner.isEmpty() && serviceName == dbusServiceName( name() ) ) {
 273         createServiceControlInterface();
 274     }
 275
 276     // an attached service was not started through ProcessControl. Thus, we cannot rely
 277     // on its restart-on-crash feature and have to do it manually. Afterwards it is back
 278     // to normals
 279     else if( d->attached &&
 280              oldOwner == dbusServiceName( name() ) ) {
 281         kDebug() << "Attached service" << name() << "went down. Restarting ourselves.";
 282         d->attached = false;
 283         start();
 284     }
 285 }
 286
 287
 288 void Nepomuk::ServiceController::createServiceControlInterface()
 289 {
 290     delete d->serviceControlInterface;
 291
 292     d->serviceControlInterface = new OrgKdeNepomukServiceControlInterface( dbusServiceName( name() ),
 293                                                                            "/servicecontrol",
 294                                                                            QDBusConnection::sessionBus(),
 295                                                                            this );
 296     connect( d->serviceControlInterface, SIGNAL( serviceInitialized( bool ) ),
 297              this, SLOT( slotServiceInitialized( bool ) ) );
 298
 299     if ( d->serviceControlInterface->isInitialized() ) {
 300         slotServiceInitialized( true );
 301     }
 302 }
 303
 304
 305 void Nepomuk::ServiceController::slotServiceInitialized( bool success )
 306 {
 307     if ( !d->initialized ) {
 308         if ( success ) {
 309             kDebug() << "Service" << name() << "initialized";
 310             d->initialized = true;
 311             emit serviceInitialized( this );
 312
 313             if ( runOnce() ) {
 314                 // we have been run once. Do not autostart next time
 315                 KConfigGroup cg( Server::self()->config(), QString("Service-%1").arg(name()) );
 316                 cg.writeEntry( "autostart", false );
 317             }
 318         }
 319         else {
 320             d->failedToInitialize = true;
 321             kDebug() << "Failed to initialize service" << name();
 322             stop();
 323         }
 324     }
 325
 326     foreach( QEventLoop* loop, d->loops ) {
 327         loop->exit();
 328     }
 329 }