VFS_ephemeral.cpp

Go to the documentation of this file.

 
#include <QDirIterator>
#include <QFile>
#include <QDir>
#include <QMimeDatabase>
#include <QMimeType>
 
#include "VFS.h"
#include "VFS_ephemeral.h"
#include "VFS_base/VFS_icons.h"
#include "utilities/rutils.h"
#include "VFS_datastore/VFS_datastore.h"
#include "VFS_base/VFS_node_type.h"
 
#define VFS_EPHEMERAL_MAX_READABLE 104857600            //100mb
 
QMimeDatabase VFS_ephemeral::_mimeDatabase;
 
VFS_ephemeral::VFS_ephemeral(bool container, bool raw)
: VFS_node()
, _container(container)
, _raw(raw)
{
        _modified = QDateTime::currentDateTimeUtc();
}
 
VFS_ephemeral::~VFS_ephemeral()
{
}
 
 
QByteArray VFS_ephemeral::icon()
{
        return VFS_node::icon();
}
 
 
QString VFS_ephemeral::reportDetails()
{
        QString s = QString("Size: %1\nModified: %2").arg(size()).arg(_modified.toString());
 
        return s;
}
 
 
VFS_node *VFS_ephemeral::find(VFS_request *r)
{
        VFS_node *n = VFS_node::find(r);
 
        if (!n && _container)
        {
                bool creating = r->_metadata.value("createIfMissing").toBool(false) || r->_requestType == VFS_request::create;
                bool container = r->_metadata.value("container").toBool(false);
                bool raw = r->_metadata.value("raw").toBool(false) || _raw;
 
                if (creating)
                {
                        QStringList pl = r->_path.split("/",Qt::SkipEmptyParts);
                        QString p = pl.takeFirst();
                        if (pl.length() == 0)
                                n = new VFS_ephemeral(container,raw);
                        else
                                n = new VFS_ephemeral(true,raw);
 
                        if (append(p,n,true,r->_user))
                        {       r->_reason = "";
                                r->_path = pl.join("/");
                                r->_prefixPath += p;
                                return n->find(r);
                        }
                        else
                        {
                                delete n;
                                n = nullptr;
                        }
                }
        }
 
        return n;
}
 
 
bool VFS_ephemeral::isContainer()
{
        return _container;
}
 
 
VFS_node *VFS_ephemeral::append(QString nodename, VFS_node *node, bool containerCheck, QString user)
{
        VFS_ephemeral *t = dynamic_cast<VFS_ephemeral *>(node);
 
        if (!t)
        {       VFS::ERROR( QString("Can only append nodes of type 'VFS_ephemeral'. Unable to append '%1'.").arg(nodename), 0, className() );
                return nullptr;
        }
        else
                t->populateMetadata(nodename);
 
        return VFS_node::append(nodename,node,containerCheck,user);
}
 
 
void VFS_ephemeral::populateMetadata(QString name)
{
        if (_container)
                return;
 
        QString t = VFS_node_type::getType(name,"");
 
        if (t == "")
        {
                QMimeType mime = _mimeDatabase.mimeTypeForFile(name);
                t = mime.name();
 
                _metadata["mime"] = t;
                _metadata["type"] = mime.comment();
        }
        else
                _metadata["type"] = t;
}
 
 
quint64 VFS_ephemeral::size()
{
        if (_raw)       return (quint64) _rawData.size();
        else            return (quint64) QJsonDocument(_data).toJson().size();
}
 
 
void VFS_ephemeral::ls(VFS_request *r)
{
        //FIXME: add stuff for "closest" and listing
 
        if (_container)
        {
                VFS_node::ls(r);
 
                if (r->_metadata.value("sequence").toBool(false) && _container)
                        r->_data.setObject( rutils::sequenceListing(r->_data.object()) );
 
                return;
        }
 
        r->_success = false;
        r->_reason = "Cannot list a file";
}
 
 
void VFS_ephemeral::read(VFS_request *r)
{
        if (isContainer() && r->_path == "")
        {
                r->_metadata["type"] = "listing";
                ls(r);
                return;
        }
 
        QMutexLocker l(&_lock);
 
        bool creating = r->_metadata.value("createIfMissing").toBool(false);
        //bool container = r->_metadata.value("container").toBool(false);
 
        bool raw = r->_metadata.value("raw").toBool(false) || _raw;
        bool range = r->_metadata.contains("range") ? true : false;
 
        if (range)
        {
                if (raw)
                        return fetchRange(r);
                else
                        VFS::WARN("Range request was present on non-raw VFS_ephemeral node.  Range will be ignored.",0,className());
        }
 
        if (creating && !size())
        {
                //printf("CREATE FROM READ: %s\n%s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_data.toJson()));
 
                _data = r->_data.object();
                _rawData = r->_rawData;
                _modified = QDateTime::currentDateTimeUtc();
        }
 
        if (raw && !_rawData.isEmpty())
                r->_rawData = _rawData;
        else
                r->_data.setObject(_data);
 
        r->_success = true;
}
 
 
void VFS_ephemeral::write(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        _data = r->_data.object();
        _rawData = r->_rawData;
        _modified = QDateTime::currentDateTimeUtc();
 
        r->_success = true;
 
        emit diff(this,r);
}
 
void VFS_ephemeral::metadata(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        r->_metadata = _metadata;
 
        VFS_node::metadata(r);
 
        if (_raw)
                r->_metadata["raw"] = true;
 
        r->_success = true;
}
 
 
void VFS_ephemeral::submit(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        //bool creating = r->_metadata.value("createIfMissing").toBool(false);
        bool raw = r->_metadata.value("raw").toBool(false) || _raw;
        QString method = r->_metadata.value("method").toString("json");
 
        if (!raw)
        {
                if (method == "delta")
                        _data["data"] = VFS_datastore::applyDeltaDiff( _data["data"].toString(), r->_data.object(), "", r->_user );
                else
                        _data = VFS_datastore::applyJsonDiff( _data, r->_data.object(), "", r->_user );
 
                r->_success = true;
 
                _modified = QDateTime::currentDateTimeUtc();
 
                emit diff(this,r);
        }
        else
        {
                if (method == "delta")
                {
                        _rawData = VFS_datastore::applyDeltaDiff( QString::fromUtf8(_rawData), r->_data.object(), "", r->_user ).toUtf8();
 
                        r->_success = true;
 
                        _modified = QDateTime::currentDateTimeUtc();
 
                        emit diff(this,r);
                }
                else
                {
                        r->_success = false;
                        r->_reason = "Can't apply a json diff to _raw data.";
                }
        }
}
 
 
void VFS_ephemeral::applyDiff(VFS_request *r)
{
        submit(r);
}
 
 
void VFS_ephemeral::fetchRange(VFS_request *r)
{
        if (!_raw)
        {
                r->_reason = "Cannot fetch range on non-raw data.";
                r->_success = false;
                return;
        }
 
        QJsonObject range = r->_metadata["range"].toObject();
 
        qint64 start(0);
        qint64 end(0);
 
        if (range.contains("s"))
                start = (qint64) range["s"].toDouble();
 
        if (range.contains("e"))
                end = (qint64) range["e"].toDouble();
 
        qint64 size = _rawData.size();
 
        if (start < 0 && -start <= size)        start = size + start;   //which should now be positive or zero
        if (end < 0 && -end <= size)            end = size + end;       //which should now be positive or zero
        if (end == 0)                           end = size - 1;         //the end of the file, which must be offset by one
 
        if (start > end)
        {
                r->_reason = QString("Can't fetch range where start >= end (%1,%2)").arg(start).arg(end);
                r->_success = false;
                return;
        }
 
        if (end - start > VFS_EPHEMERAL_MAX_READABLE)
        {
                r->_reason = QString("Won't fetch range greater than %1 bytes.  Requested %2 bytes.").arg(VFS_EPHEMERAL_MAX_READABLE).arg(end-start+1);
                r->_success = false;
                return;
        }
 
        if (start >= size || end >= size)
        {
                r->_reason  = QString("Can't fetch beyond the end of data.  Requested bytes %1-%2").arg(start).arg(end);
                r->_success = false;
                return;
        }
 
        qint64 bytes = end - start + 1;
 
        if (start < _rawData.size())
        {
                QByteArray data(_rawData.data(),(int)bytes);
 
                if (data.length() != bytes)
                {
                        r->_reason = QString("Could not read %1 bytes.  Requested bytes %2-%3, but only %4 were returned.").arg(bytes).arg(start).arg(end).arg(data.length());
                        r->_success = false;
                        return;
                }
 
                range["s"] = start;
                range["e"] = end;
                r->_metadata["range"] = range;
 
                r->_rawData = data;
                r->_success = true;
        }
        else
        {
                r->_reason  = QString("Start value is out of range.  Requested bytes %1-%2").arg(start).arg(end);
                r->_success = false;
                return;
        }
}