VFS_datastore.cpp

Go to the documentation of this file.

 
#include <QTimerEvent>
#include <QtGlobal>
//#include <QThread>
 
#include "VFS.h"
#include "VFS_datastore.h"
 
VFS_datastore_cache_entry::VFS_datastore_cache_entry(bool debug, int flushInterval, int expireInterval, bool raw)
: QObject()
, _data()
, _rawData()
, _size(0)
, _raw(raw)
, _dirty(false)
, _valid(false)
, _reason("")
, _debug(debug)
, _flushInterval(flushInterval)
, _expireID(0)
, _expireInterval(expireInterval)
{
        _expireInterval = qMax(_expireInterval,flushInterval);
 
        if (flushInterval > 0)
                _flushID = startTimer(flushInterval);                           //this always runs, regardless of touch() status, because we need to flush at some point!
 
        touch();                                                                //start the expire timer and set the ID
}
 
VFS_datastore_cache_entry::~VFS_datastore_cache_entry()
{
        //printf("DATASTORE CACHE ENTRY DTOR: %p '%s'\n",this,qUtf8Printable(_key));
 
        if (_dirty && _valid)
                printf("WARNING: deleting dirty cache entry: '%s'\n",qUtf8Printable(_key));
}
 
void VFS_datastore_cache_entry::timerEvent(QTimerEvent *event)
{
        int id = event->timerId();
 
        if (id == _flushID)
        {
                if (!_valid)
                {       VFS::ERROR(_reason);
                        VFS::CRITICAL("Deleting invalid cache entry.  Data may be lost.\n"+_reason);
                        emit expired(this);
                        return;
                }
 
                if (_dirty)
                        flush();
 
                if (_dirty)                                                     //if it's still dirty, there's a serious problem.  Report it.
                        VFS::CRITICAL(_reason);
        }
        else if (id == _expireID)
        {
                //printf("EXPIRE DATASTORE ENTRY!\n");
 
                if (!_valid)
                {       VFS::ERROR(_reason);
                        VFS::CRITICAL("Deleting invalid cache entry.  Data may be lost.\n"+_reason);
                        emit expired(this);
                        return;
                }
 
                if (_dirty)
                        flush();
 
                if (_dirty)                                                     //if it's still dirty, there's a serious problem.  Report it.
                        VFS::CRITICAL(_reason);
                else
                        emit expired(this);
        }
        else
                printf("Bad timerId: %d!\n",id);
}
 
quint64 VFS_datastore_cache_entry::size()
{
        return _size;
}
 
void VFS_datastore_cache_entry::setData(QJsonObject json)
{
        //_size = QJsonDocument(json).toJson().size();
        _data.setObject(json);
        //int s;
        //_data.rawData( &s );  //get the encoded size of the data
        //_size = s;
        _size = (quint64) _data.toJson().size();
 
        _dirty = true;
 
        touch();
}
 
QJsonDocument VFS_datastore_cache_entry::getData()
{
        touch();
 
        return _data;
}
 
void VFS_datastore_cache_entry::setData(QByteArray data)
{
        _rawData = data;
        _size = data.size();
 
        _dirty = true;
 
        touch();
}
 
QByteArray VFS_datastore_cache_entry::getRawData()
{
        touch();
 
        return _rawData;
}
 
bool VFS_datastore_cache_entry::valid(QString &reason)
{
        if (!_valid)
                reason=_reason;
 
        return _valid;
}
 
void VFS_datastore_cache_entry::touch()
{
        if (_expireInterval>0)
        {       _expireTimer.start(_expireInterval,this);                                       //push expiration into the future
                _expireID = _expireTimer.timerId();
        }
 
        emit touched();
}
 
VFS_datastore_cache::VFS_datastore_cache(quint64 size)
: QCache<QString, VFS_datastore_cache_entry>(size)
{
}
 
VFS_datastore_cache::~VFS_datastore_cache()
{
}
 
/*
VFS_datastore_cache_entry *VFS_datastore_cache::createEntry(QString p)
{
        Q_UNUSED(p);
 
        printf("VFS_datastore_cache::createEntry() must be subclassed.\n");
 
        return 0;
}
 
VFS_datastore_cache_entry *VFS_datastore_cache::operator [](QString p)
{
        VFS_datastore_cache_entry *e;
 
        if (!(e = object(p)))
        {       e = createEntry(p);
                if (!insert(p,e,e->size()))
                {
                        VFS::WARN( QString("'%2' was too large to cache!").arg(p) );
                        e->deleteLater();
                }
        }
 
        return e;
}
*/
 
 
bool VFS_datastore_cache::insert(const QString &key, VFS_datastore_cache_entry *object)
{
        quint64 size = object->size();
        object->_key = key;
 
        if (QCache<QString, VFS_datastore_cache_entry>::totalCost() + size > (quint64) maxCost())
                return false;
 
        //printf("DATASTORE CACHE INSERT: %p %p '%s' @ %s\n",this,object,qUtf8Printable(key),qUtf8Printable(this->thread()->objectName()));
 
        bool i = QCache<QString, VFS_datastore_cache_entry>::insert(key,object,size);
 
        if (i)
        {
                object->connect(object,SIGNAL(expired(VFS_datastore_cache_entry*)),this,SLOT(expired(VFS_datastore_cache_entry*)),Qt::UniqueConnection);
                object->connect(object,SIGNAL(touched()),this,SLOT(touched()),Qt::UniqueConnection);
        }
 
        return i;
}
 
void VFS_datastore_cache::expired(VFS_datastore_cache_entry *e)
{
        bool s = QCache<QString, VFS_datastore_cache_entry>::remove(e->_key);
 
        if (!s)
                VFS::WARN("WARN: VFS_datastore_cache tried to remove an entry that wasn't cached.\n");
 
        //printf("%p TOTAL COST: %d\n",this,totalCost());
}
 
 
void VFS_datastore_cache::touched()
{
        VFS_datastore_cache_entry *e = qobject_cast<VFS_datastore_cache_entry *>( sender() );
 
        if (e)
        {
                //assuming this updates the key in the cache
                object(e->_key);
        }
        else
        {
                VFS::WARN("A cache entry failed to be touched.");
        }
}
 
 
VFS_datastore::VFS_datastore(quint64 size, bool debug)
: VFS_node()
, _cache(size)
, _debug(debug)
{
}
 
VFS_datastore::~VFS_datastore()
{
}
 
 
bool VFS_datastore::isContainer()
{
        return true;
}
 
 
VFS_node *VFS_datastore::find(VFS_request *r)
{
        Q_UNUSED(r)
 
        return this;
}
 
 
QString VFS_datastore::reportDetails()
{
        QString s = QString("Max Cost: %1\nTotal cost: %2\nTotal entries: %3").arg(_cache.maxCost()).arg(_cache.totalCost()).arg(_cache.size());
 
        return s;
}
 
QJsonObject VFS_datastore::applyJsonDiff(QJsonObject obj, QJsonObject diff, QString trace, QString user)
{
        bool _debug = false;
 
        QJsonObject::iterator i = diff.begin();
 
        int L = 9;
 
        while (i != diff.end())                                                 //iterate through the diff entries and apply them
        {
                //if the value for the entry is null
                        //delete the field
                //if the value is an object
                        //recursively merge
                //if the value is not an object
                        //add if not exist
                        //update/set otherwise
 
                if (_debug)
                        VFS::WARN( QString("%1 => %2").arg(i.key()).arg(i.value().toString()) );
 
                QString var = i.key();
                QJsonValue val = i.value();
 
                //VFS::ERROR(QString("type: %1").arg(val.type()) );
                //printf("type: %d\n",val.type() );
 
                if (val.isNull())       //remove field
                {
                        //printf("%s apply diff case 1\n",qUtf8Printable(var));
                        obj.remove(var);
 
                        if (_debug)
                                VFS::WARN( QString("%1%2 => (removed)").arg(trace).arg(var), L, user );
                }
                else if (val.isArray())
                {
                        //printf("%s apply diff case 2\n",qUtf8Printable(var));
                        //obj[var] = val;
                        obj.insert(var,val);
 
                        if (_debug)
                                VFS::WARN( QString("%1%2 => '%3'").arg(trace).arg(var).arg( QString(QJsonDocument(val.toArray()).toJson()).replace('\n',"") ), L, user );
                }
                else if (val.isObject() && obj.contains(var) && obj[var].isObject())
                {
                        //printf("%s apply diff case 3\n",qUtf8Printable(var));
                        //obj[var] = applyJsonDiff( obj[var].toObject(), val.toObject(), trace+var+".", user );
                        obj.insert(var,applyJsonDiff( obj[var].toObject(), val.toObject(), trace+var+".", user ));
                }
                else                    //update or create field
                {
                        //printf("%s apply diff case 4\n",qUtf8Printable(var));
                        //obj[var] = val;
 
                        if (obj.contains(var))
                        {
                                QJsonValue vv = obj[var];
 
                                if (vv.isObject())              //upgrade the value to a value field
                                {
                                        QJsonObject oo = vv.toObject();
                                        oo["value"] = val;
                                        obj.insert(var,oo);
                                }
                                else
                                        obj.insert(var,val);
 
                        }
                        else
                                obj.insert(var,val);
 
                        if (_debug)
                        {
                                if (val.isString())
                                        VFS::WARN( QString("%1%2 => '%3'").arg(trace).arg(var).arg(val.toString()), L, user );
                                else if (val.isDouble())
                                        VFS::WARN( QString("%1%2 => %3").arg(trace).arg(var).arg(val.toDouble()), L, user );
                                else if (val.isBool())
                                        VFS::WARN( QString("%1%2 => %3").arg(trace).arg(var).arg(val.toBool() ? "true" : "false"), L, user );
                                else if (val.isObject())
                                        VFS::WARN( QString("%1%2 => %3").arg(trace).arg(var).arg("[object]"), L, user );
                                else
                                        VFS::WARN( QString("%1%2 => %3").arg(trace).arg(var).arg("UNKNOWN TYPE"), L, user );
                        }
                }
 
                ++i;
        }
 
        return obj;
}
 
QString VFS_datastore::applyDeltaDiff(QString data, QJsonObject diff, QString trace, QString user)
{
        bool _debug = true;
        int L = 9;
 
        QJsonObject delta = diff["delta"].toObject();
 
        QString action = delta["action"].toString();
        int srow = delta["start"].toObject()["row"].toInt();
        int scol = delta["start"].toObject()["column"].toInt();
        int erow = delta["end"].toObject()["row"].toInt();
        int ecol = delta["end"].toObject()["column"].toInt();
        QStringList dlines;
        foreach (const QJsonValue & value, delta["lines"].toArray()) {
                dlines << value.toString();
        }
 
        //QString data = obj["data"].toString();
        QStringList lines = data.split("\n");
 
        if (_debug)
                VFS::WARN( QString("Delta: %1%2 => '%3'").arg(trace).arg(action).arg(dlines.join("\n")), L, user );
 
        if (action=="remove")
        {
                if (srow >= 0 && srow < lines.length())
                {
                        if (srow == erow)               //remove a chunk of one line
                        {
                                lines[srow].remove(scol,ecol-scol);
                        }
                        else if (erow > srow)   //remove an ending and a beginning, and possibly some rows in between
                        {
                                //lines[srow].truncate(scol);
                                //lines[erow].remove(0,ecol);
                                lines[srow] = lines[srow].left(scol) + lines[erow].remove(0,ecol);
                                for (int i=srow+1,j=srow+1;i<=erow;i++)
                                        lines.removeAt(j);
                        }
                        else
                                VFS::ERROR( QString("%1Bad delta.  Remove start row greater than end row.").arg(trace), 0, user );
                }
                else
                        VFS::ERROR( QString("%1Bad delta.  Remove start row out of bounds.").arg(trace), 0, user );
        }
        else if (action=="insert")
        {
                if (srow >= 0 && srow < lines.length())
                        lines[srow] = lines[srow].insert(scol,dlines.join("\n"));
                else
                        VFS::ERROR( QString("%1Bad delta.  Insert start row out of bounds.").arg(trace), 0, user );
        }
 
        //obj["data"] = lines.join("\n");
        //return obj;
 
        return lines.join("\n");
}