Blokkal

an Extendable KDE Blogging Client

• Download
• Screenshots
• LiveJournal Community
• API Documentation
• Contact

• Class Hierarchy
• Class List
• File List
• Class Members

blokkalpostentryqueue.cpp

/***************************************************************************
 *   Copyright (C) 2006 - 2008 by Martin Mueller                           *
 *   orvio@orvio.de                                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "blokkalpostentryqueue.h"
#include "blokkalpostentryqueue.moc"

#include "blokkalentry.h"
#include "blokkalblog.h"
#include "blokkalaccount.h"
#include "blokkalaccountmanager.h"
#include "blokkalio/jobs.h"

#include <kdebug.h>
#include <klocale.h>
#include <kstandarddirs.h>

#include <QMap>
#include <QTimer>
#include <QDir>
#include <QLinkedList>

class Blokkal::PostEntryStatus::Private
{
public:
        Private( void ) {}

        Status status;
        int error;
        QString errorString;
        Io::EntryJob * job;

        long saveNumber;
};

Blokkal::PostEntryStatus::PostEntryStatus( void ) :
d( new Private() )
{
        d->status = StatusNormal;
        d->error = 0;
        d->errorString = QString::null;
        d->job = 0;

        d->saveNumber = -1;
}

Blokkal::PostEntryStatus::~PostEntryStatus( void )
{
        delete d;
}

int Blokkal::PostEntryStatus::error( void ) const
{
        return d->error;
}

QString Blokkal::PostEntryStatus::errorString( void ) const
{
        return d->errorString;
}

Blokkal::PostEntryStatus::Status Blokkal::PostEntryStatus::status( void ) const
{
        return d->status;
}

const Blokkal::Io::EntryJob * Blokkal::PostEntryStatus::job( void ) const
{
        return d->job;
}

//--------------
//PostEntryQueue
//--------------
class Blokkal::PostEntryQueuePrivate
{
public:
        PostEntryQueuePrivate( void ) :
        entryStatus( QMap<Blokkal::Entry*, PostEntryStatus*>() ),
        entryList( QLinkedList<Blokkal::Entry*>() ),
        //queueLock( TRUE ), // recursive mutex
        isProcessing( TRUE ),
        saveNumber( 0 ),
        isSyncing( TRUE ) {}

        Blokkal::PostEntryQueue instance;

        QMap<Blokkal::Entry*, PostEntryStatus*> entryStatus;
        QLinkedList<Blokkal::Entry*> entryList;

        //QMutex queueLock;
        bool isProcessing;
        long saveNumber;
        bool isSyncing;
};

K_GLOBAL_STATIC( Blokkal::PostEntryQueuePrivate, _bpeqp );

Blokkal::PostEntryQueue::PostEntryQueue( void ):
QObject( 0 )
{
        QList< Blokkal::Account * > accounts = Blokkal::AccountManager::self()->accounts();
        if( !accounts.isEmpty() ) {
                for( QList< Blokkal::Account * >::ConstIterator it = accounts.begin();
                     it != accounts.end();
                     ++it )
                {
                        slotAccountAdded( *it );
                }
        }

        connect( Blokkal::AccountManager::self(),
                 SIGNAL( accountRegistered( Blokkal::Account * ) ),
                 SLOT( slotAccountAdded( Blokkal::Account * ) ) );
}

Blokkal::PostEntryQueue::~PostEntryQueue( void )
{
}

Blokkal::PostEntryQueue * Blokkal::PostEntryQueue::self( void )
{
        return &_bpeqp->instance;
}

void Blokkal::PostEntryQueue::queue( Blokkal::Entry * entry )
{
        if( !entry ) {
                return;
        }

        entry->ref(); //the view might close after queing the entry
        
        //_bpeqp->queueLock.lock();
        connect( entry,
                 SIGNAL( entryDestroyed( Blokkal::Entry * ) ),
                 SLOT( slotEntryDestroyed( Blokkal::Entry * ) ) );
        _bpeqp->entryStatus.insert( entry, new PostEntryStatus() );
        _bpeqp->entryList.append( entry );
        //_bpeqp->queueLock.unlock();

        if( _bpeqp->isSyncing ) {
                entry->saveAs( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "queuedentries/%1" ).arg( _bpeqp->saveNumber ) ) );
                _bpeqp->entryStatus[entry]->d->saveNumber = _bpeqp->saveNumber;
                _bpeqp->saveNumber++;
        }
        
        emit entryAdded( entry );
        
        QTimer::singleShot( 0, this, SLOT( processQueue( void ) ) );
}

bool Blokkal::PostEntryQueue::unqueue( Blokkal::Entry * entry, bool force )
{
        //_bpeqp->queueLock.lock();
        bool removed = FALSE;
        bool contains = _bpeqp->entryList.contains( entry );
        long saveNumber = -1;

        if( contains ) {
                if( _bpeqp->entryStatus.contains( entry) ) {
                        PostEntryStatus * status = _bpeqp->entryStatus[entry];
                        if( status->status() != PostEntryStatus::StatusPosting
                                || force )
                        {
                                saveNumber = status->d->saveNumber;
                                delete status->d->job;
                                delete status;
                                _bpeqp->entryStatus.remove( entry );
                                removed = TRUE;
                        }
                }
                else {
                        removed = TRUE;
                }

                if( removed ) {
                        _bpeqp->entryList.removeAll( entry );
                        disconnect( entry,
                                    SIGNAL( entryDestroyed( Blokkal::Entry* ) ),
                                    this,
                                    SLOT( slotEntryDestroyed( Blokkal::Entry* ) ) );
                }
        }
        //_bpeqp->queueLock.unlock();

        if( removed ) {
                if( _bpeqp->isSyncing && saveNumber >= 0 ) {
                        QDir entrydir( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "queuedentries/" ) ) );
                        QString fileName = QString::number( saveNumber );
                        if( !entrydir.remove( fileName ) ) {
                                kWarning() << "could not delete entry file: " << fileName << endl;
                        }
                }

                if( isEmpty() ) {
                        _bpeqp->saveNumber = 0;
                }
                
                emit entryRemoved( entry );
        }

        return removed;
}

int Blokkal::PostEntryQueue::count( void ) const
{
        return _bpeqp->entryStatus.count();
}

bool Blokkal::PostEntryQueue::isEmpty( void ) const
{
        return !count();
}

QLinkedList< Blokkal::Entry * > Blokkal::PostEntryQueue::entries( void ) const
{
        return _bpeqp->entryList;
}

void Blokkal::PostEntryQueue::processQueue( void )
{
        if( !_bpeqp->isProcessing || isEmpty() ) {
                return;
        }

        //_bpeqp->queueLock.lock();
        QStringList postingAccounts;
        for( QLinkedList< Blokkal::Entry * >::Iterator it = _bpeqp->entryList.begin();
             it != _bpeqp->entryList.end();
             ++it )
        {
                if( !(*it)->blog()->account()->isConnected() ) {
                        continue;
                }

                if( postingAccounts.contains( (*it)->blog()->account()->id() ) ) {
                        continue;
                }

                PostEntryStatus * entryStatus = _bpeqp->entryStatus[ *it ];
                
                if( entryStatus->status() != PostEntryStatus::StatusNormal ) {
                        if( entryStatus->status() == PostEntryStatus::StatusPosting
                            && !postingAccounts.contains( (*it)->blog()->account()->id() ) )
                        {
                                postingAccounts.append( (*it)->blog()->account()->id() );
                        }
                        continue;
                }

                if( entryStatus->error() ) {
                        continue;
                }

                entryStatus->d->job = (*it)->createJob( Blokkal::Entry::PostJob );
                if( entryStatus->d->job ) {
                        connect( entryStatus->d->job,
                                 SIGNAL( result( KJob * ) ),
                                 SLOT( slotJobFinished( KJob * ) ) );
                        entryStatus->d->status =  PostEntryStatus::StatusPosting;
                        emit entryStatusChanged( *it, entryStatus );
                        entryStatus->d->job->start();
                        break; //ensure that no entry is posted out of order
                }
                else {
                        //if we end up here, the entry implementation does not support posting
                        //entries. While this may seem braindead it may help
                        //when implementing new protocols, because not all methods need to be
                        //fully operational.
                        entryStatus->d->status =  PostEntryStatus::StatusError;
                        emit entryStatusChanged( *it, entryStatus );
                        //process next entry in queue
                        continue;
                }
        }
        
        //_bpeqp->queueLock.unlock();
}

void Blokkal::PostEntryQueue::slotJobFinished( KJob * _job )
{
        Io::EntryJob * job = dynamic_cast<Io::EntryJob *>( _job );
        if( !job ) {
                kError() << "job is 0!" << endl;
                return;
        }

        if( !_bpeqp->entryStatus.contains( job->entry() ) ) {
                kError() << "job is belongs to unknown entry!" << endl;
                return;
        }

        if( job->error() ) {
                //_bpeqp->queueLock.lock();
                PostEntryStatus * entryStatus = _bpeqp->entryStatus[ job->entry() ];
                entryStatus->d->status = PostEntryStatus::StatusError;
                entryStatus->d->errorString = job->errorString();
                entryStatus->d->error = job->error();
                entryStatus->d->job = 0;
                //_bpeqp->queueLock.unlock();

                emit entryStatusChanged( job->entry(), entryStatus );
                emit entryFailing( job->entry() );
        }
        else {
                PostEntryStatus * entryStatus = _bpeqp->entryStatus[ job->entry() ];
                entryStatus->d->status = PostEntryStatus::StatusNormal;
                entryStatus->d->job = 0;

                job->entry()->setDirty( FALSE );
                unqueue( job->entry() );
                emit entryPosted( job->entry() );
                job->entry()->deref();
        }

        QTimer::singleShot( 0, this, SLOT( processQueue( void ) ) );
}

void Blokkal::PostEntryQueue::slotConnectionsChanged( Blokkal::Account * account )
{
        if( account->connectionStatus() == Blokkal::Account::Connected ) {
                QTimer::singleShot( 0, this, SLOT( processQueue( void ) ) );
        }
}

void Blokkal::PostEntryQueue::slotAccountAdded( Blokkal::Account * account )
{
        connect( account,
                 SIGNAL( connectionStatusChanged( Blokkal::Account * ) ),
                 SLOT(slotConnectionsChanged( Blokkal::Account * ) ) );
}

const Blokkal::PostEntryStatus * Blokkal::PostEntryQueue::entryStatus( Blokkal::Entry * entry ) const
{
        if( _bpeqp->entryStatus.contains( entry ) ) {
                return _bpeqp->entryStatus[ entry ];
        }
        return 0;
}

void Blokkal::PostEntryQueue::clearError( Blokkal::Entry * entry )
{
        if( !entry ) {
                return;
        }
        
        if( !_bpeqp->entryStatus.contains( entry ) ) {
                return;
        }

        if( !_bpeqp->entryStatus[ entry ]->error() ) {
                return;
        }

        //_bpeqp->queueLock.lock();
        PostEntryStatus * entryStatus = _bpeqp->entryStatus[ entry ];
        entryStatus->d->error = 0;
        entryStatus->d->errorString = QString::null;
        entryStatus->d->status = PostEntryStatus::StatusNormal;
        //_bpeqp->queueLock.unlock();
        emit entryStatusChanged( entry, entryStatus );

        QTimer::singleShot( 0, this, SLOT( processQueue( void ) ) );
}

void Blokkal::PostEntryQueue::slotEntryDestroyed( Blokkal::Entry * entry )
{
        unqueue( entry, TRUE );
}

void Blokkal::PostEntryQueue::suspendProcessing( void )
{
        _bpeqp->isProcessing = FALSE;
}

void Blokkal::PostEntryQueue::resumeProcessing( void )
{
        if( _bpeqp->isProcessing ) {
                return;
        }

        _bpeqp->isProcessing = TRUE;

        QTimer::singleShot( 0, this, SLOT( processQueue( void ) ) );
}

bool Blokkal::PostEntryQueue::isProcessing( void ) const
{
        return _bpeqp->isProcessing;
}

void Blokkal::PostEntryQueue::restoreState( void )
{
        QDir entrydir( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "queuedentries/" ) ) );
        QStringList files = entrydir.entryList( QDir::Files );
        if( files.isEmpty() ) {
                return;
        }

        suspendProcessing();

        long minNumber = -1;
        long maxNumber = -1;
        
        for( QStringList::ConstIterator it = files.begin();
             it != files.end();
             ++it )
        {
                bool ok;
                long currentNumber = (*it).toLong( &ok );
                if( !ok ) {
                        kWarning() << "encountered invalid file in queue dir: " << *it << endl;
                        continue;
                }
                
                if( currentNumber < minNumber || minNumber < 0 ) {
                        minNumber = currentNumber;
                }

                if( currentNumber > maxNumber ) {
                        maxNumber = currentNumber;
                }
        }


        _bpeqp->isSyncing = FALSE;
        for( long i = minNumber; i <= maxNumber; ++i ) {
                if( !files.contains( QString::number( i ) ) ) {
                        continue;
                }
                        
                Entry * entry = Entry::open( entrydir.absolutePath() + QString::fromLatin1("/%1").arg( i ) , 0, FALSE );
                if( entry ) {
                        entry->setDirty( TRUE );
                        queue( entry );
                        _bpeqp->entryStatus[entry]->d->saveNumber = i;
                }
                else {
                        kWarning() << "failed to restore entry file: " << i << endl;
                }
        }
        _bpeqp->isSyncing = TRUE;
        _bpeqp->saveNumber = maxNumber + 1;

        resumeProcessing();
}

void Blokkal::PostEntryQueue::stopSyncing( void )
{
        _bpeqp->isSyncing = FALSE;
}