runtime/nepomuk/services/ontologyloader/ontologyloader.cpp

   1 /* This file is part of the KDE Project
   2    Copyright (c) 2007 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 "ontologyloader.h"
  20 #include "ontologymanagermodel.h"
  21 #include "ontologymanageradaptor.h"
  22 #include "graphretriever.h"
  23
  24 #include <Soprano/Global>
  25 #include <Soprano/Node>
  26 #include <Soprano/Model>
  27 #include <Soprano/PluginManager>
  28 #include <Soprano/StatementIterator>
  29 #include <Soprano/Parser>
  30
  31 #include <KDesktopFile>
  32 #include <KConfigGroup>
  33 #include <KDebug>
  34 #include <KGlobal>
  35 #include <KStandardDirs>
  36 #include <KLocale>
  37 #include <KDirWatch>
  38
  39 #include <QtCore/QFileInfo>
  40 #include <QtCore/QTimer>
  41
  42 #include <kpluginfactory.h>
  43 #include <kpluginloader.h>
  44
  45 NEPOMUK_EXPORT_SERVICE( Nepomuk::OntologyLoader, "nepomukontologyloader")
  46
  47
  48 using namespace Soprano;
  49
  50 class Nepomuk::OntologyLoader::Private
  51 {
  52 public:
  53     Private( OntologyLoader* p )
  54         : forceOntologyUpdate( false ),
  55           q( p ) {
  56     }
  57
  58     OntologyManagerModel* model;
  59
  60     QTimer updateTimer;
  61     bool forceOntologyUpdate;
  62     QStringList desktopFilesToUpdate;
  63
  64     void updateOntology( const QString& filename );
  65
  66 private:
  67     OntologyLoader* q;
  68 };
  69
  70
  71 void Nepomuk::OntologyLoader::Private::updateOntology( const QString& filename )
  72 {
  73     KDesktopFile df( filename );
  74
  75     // only update if the modification date of the ontology file changed (not the desktop file).
  76     // ------------------------------------
  77     QFileInfo ontoFileInf( df.readPath() );
  78     QDateTime ontoLastModified = model->ontoModificationDate( df.readUrl() );
  79     bool update = false;
  80
  81     if ( ontoLastModified < ontoFileInf.lastModified() ) {
  82         kDebug() << "Ontology" << df.readUrl() << "needs updating.";
  83         update = true;
  84     }
  85     else {
  86         kDebug() << "Ontology" << df.readUrl() << "up to date.";
  87     }
  88
  89     if( !update && forceOntologyUpdate ) {
  90         kDebug() << "Ontology update forced.";
  91         update = true;
  92     }
  93
  94     if( update ) {
  95         QString mimeType = df.desktopGroup().readEntry( "MimeType", QString() );
  96
  97         const Soprano::Parser* parser
  98             = Soprano::PluginManager::instance()->discoverParserForSerialization( Soprano::mimeTypeToSerialization( mimeType ),
  99                                                                                   mimeType );
 100         if ( !parser ) {
 101             kDebug() << "No parser to handle" << df.readName() << "(" << mimeType << ")";
 102             return;
 103         }
 104
 105         kDebug() << "Parsing" << df.readPath();
 106
 107         Soprano::StatementIterator it = parser->parseFile( df.readPath(),
 108                                                            df.readUrl(),
 109                                                            Soprano::mimeTypeToSerialization( mimeType ),
 110                                                            mimeType );
 111         if ( !parser->lastError() ) {
 112             model->updateOntology( it, df.readUrl() );
 113             emit q->ontologyUpdated( df.readUrl() );
 114         }
 115         else {
 116             emit q->ontologyUpdateFailed( df.readUrl(), i18n( "Parsing of file %1 failed (%2)", df.readPath(), parser->lastError().message() ) );
 117         }
 118     }
 119 }
 120
 121
 122
 123 Nepomuk::OntologyLoader::OntologyLoader( QObject* parent, const QList<QVariant>& )
 124     : Service( parent ),
 125       d( new Private(this) )
 126 {
 127     ( void )new OntologyManagerAdaptor( this );
 128
 129     d->model = new OntologyManagerModel( mainModel(), this );
 130     connect( &d->updateTimer, SIGNAL(timeout()), this, SLOT(updateNextOntology()) );
 131
 132     // only update changed ontologies
 133     updateLocalOntologies();
 134
 135     // watch both the global and local ontology folder for changes
 136     KDirWatch* dirWatch = KDirWatch::self();
 137     connect( dirWatch, SIGNAL( dirty(QString) ),
 138              this, SLOT( updateLocalOntologies() ) );
 139     connect( dirWatch, SIGNAL( created(QString) ),
 140              this, SLOT( updateLocalOntologies() ) );
 141     foreach( const QString& dir, KGlobal::dirs()->findDirs( "data", QString() ) ) {
 142         // we only add the suffix here to make sure to also watch the non-existing local dir
 143         kDebug() << "watching" << ( dir + "nepomuk/ontologies/" );
 144         dirWatch->addDir( dir + "nepomuk/ontologies/", KDirWatch::WatchFiles );
 145     }
 146 }
 147
 148
 149 Nepomuk::OntologyLoader::~OntologyLoader()
 150 {
 151     delete d;
 152 }
 153
 154
 155 void Nepomuk::OntologyLoader::updateLocalOntologies()
 156 {
 157     d->desktopFilesToUpdate = KGlobal::dirs()->findAllResources( "data", "nepomuk/ontologies/*.desktop" );
 158     d->updateTimer.start(0);
 159 }
 160
 161
 162 void Nepomuk::OntologyLoader::updateAllLocalOntologies()
 163 {
 164     d->forceOntologyUpdate = true;
 165     updateLocalOntologies();
 166 }
 167
 168
 169 void Nepomuk::OntologyLoader::updateNextOntology()
 170 {
 171     if( !d->desktopFilesToUpdate.isEmpty() ) {
 172         d->updateOntology( d->desktopFilesToUpdate.takeFirst() );
 173     }
 174     else {
 175         d->forceOntologyUpdate = false;
 176         d->updateTimer.stop();
 177     }
 178 }
 179
 180
 181 QString Nepomuk::OntologyLoader::findOntologyContext( const QString& uri )
 182 {
 183     return QString::fromAscii( d->model->findOntologyContext( QUrl::fromEncoded( uri.toAscii() ) ).toEncoded() );
 184 }
 185
 186
 187 void Nepomuk::OntologyLoader::importOntology( const QString& url )
 188 {
 189     connect( GraphRetriever::retrieve( url ), SIGNAL( result( KJob* ) ),
 190              this, SLOT( slotGraphRetrieverResult( KJob* ) ) );
 191 }
 192
 193
 194 void Nepomuk::OntologyLoader::slotGraphRetrieverResult( KJob* job )
 195 {
 196     GraphRetriever* graphRetriever = static_cast<GraphRetriever*>( job );
 197     if ( job->error() ) {
 198         emit ontologyUpdateFailed( QString::fromAscii( graphRetriever->url().toEncoded() ), graphRetriever->errorString() );
 199     }
 200     else {
 201         // TODO: find a way to check if the imported version of the ontology
 202         // is newer than the already installed one
 203         if ( d->model->updateOntology( graphRetriever->statements(), graphRetriever->url() ) ) {
 204             emit ontologyUpdated( QString::fromAscii( graphRetriever->url().toEncoded() ) );
 205         }
 206         else {
 207             emit ontologyUpdateFailed( QString::fromAscii( graphRetriever->url().toEncoded() ), d->model->lastError().message() );
 208         }
 209     }
 210 }
 211
 212 #include "ontologyloader.moc"