VFS_hd.cpp

Go to the documentation of this file.

 
#include <QDirIterator>
#include <QFile>
#include <QDir>
#include <QMimeDatabase>
#include <QMimeType>
 
#include "VFS.h"
#include "VFS_hd.h"
#include "VFS_base/VFS_icons.h"
#include "utilities/rutils.h"
 
#include "VFS_base/VFS_node_type.h"
 
 
//#define VFS_HD_MAX_CACHEABLE 104857600        //100mb
#define VFS_HD_MAX_READABLE 104857600           //100mb
 
//QFileSystemWatcher VFS_HD_cache_entry::_watcher();
QMimeDatabase VFS_HD::_mimeDatabase;
 
VFS_HD_cache_entry::VFS_HD_cache_entry(QString path, bool debug, int flushInterval, int expireInterval, bool create, bool container, bool raw, bool watch)
: VFS_datastore_cache_entry(debug,flushInterval,expireInterval,raw)
, _path(path)
, _info(path)
, _watcher(this)
{
        //_path = _info.canonicalFilePath();
 
        if (watch)
        {
                _watcher.addPath(path);
                connect(&_watcher, SIGNAL(directoryChanged(const QString &)), this, SLOT(modified(const QString &)));
                connect(&_watcher, SIGNAL(fileChanged(const QString &)), this, SLOT(modified(const QString &)));
        }
 
        if (_debug)
                VFS::LOG( QString("Cache created: '%1'").arg(_path) );
 
        if (!_info.exists())
        {
                if (create)
                {
                        //printf("creating: %s\n",qUtf8Printable(_path));
 
                //      if (_info.exists())
                //      {       VFS::ERROR( _reason = QString("Create would overwrite file '%1'").arg(_path) );
                //              _valid = false;
                //      }
                //      else
                        {
                                QDir d = _info.dir();
                                if (!d.mkpath(d.path()))
                                        if (_debug)
                                                printf("CAN'T CREATE PATH FOR WRITE: %s\n",qUtf8Printable(_path));
 
                                //printf("creating: %s\n",qUtf8Printable(_path));
 
                                if (!container)
                                {
                                        QFile file(_path);
                                        if (file.open(QFile::WriteOnly))
                                        {
                                                file.write(_raw?"":"{}");                       //create an empty file or empty json file
                                                _valid = true;
                                                _size = 1;                                      //FIXME: a size should be reported to the cache
                                                file.close();
                                                _dirty = true;
                                        }
                                        else
                                        {       VFS::ERROR( QString("Can't create file: %1").arg(_path) );
                                                _valid = false;
                                        }
                                }
                                else
                                {
                                        if (d.mkdir(_path))
                                        {       _valid = true;
                                                _size = 1;
                                                _dirty = false;
                                        }
                                        else
                                                VFS::ERROR( QString("Can't create directory: %1").arg(_path) );
                                }
                        }
 
                        return;
                }
                else
                {
                        _reason = QString("Entry does not exist: '%1'.").arg(_path);
                        _valid = false;
                        return;
                }
        }
 
        if (!_info.isReadable())
        {
                _reason = QString("Permission denied: '%1'.").arg(_path);
                _valid = false;
                return;
        }
 
        if (_info.isDir())
        {
                QDir dir(_path);
                QFileInfoList list = dir.entryInfoList( QDir::AllEntries | QDir::Readable | QDir::NoDotAndDotDot );
 
                QJsonObject o;
                QFileInfo info;
 
                for (int i=0;i<list.length();i++)
                {
                        info = list[i];
 
                        /*
                        QJsonObject e;
                        e["name"] = info.baseName();
                        e["path"] = info.fileName();
                        e["container"] = info.isDir();
 
                        o[info.fileName()] = e;
                        */
                        o[info.fileName()] = info.isDir();
                }
 
                _valid = true;
                //_size = qMax(1,list.length());                                //FIXME: not sure where else to get size!
                _size = o.keys().join("").length();
                setData(o);
                _dirty = false;
        }
        else
        {
                QFile file(_path);
                if(file.open(QFile::ReadOnly))
                {
                        qint64 s = file.size();
 
                        if (s > VFS_HD_MAX_READABLE)
                        {
                                _reason = QString("Won't read files greater than %1 bytes.  Requested file was %2 bytes.").arg(VFS_HD_MAX_READABLE).arg(s);
                                _valid = false;
                                return;
                        }
 
                        QByteArray f = file.readAll();
 
                        if (!_raw)
                        {
                                if (f.size())
                                {
                                        QJsonDocument d;
                                        QJsonParseError e;
                                        d = QJsonDocument::fromJson(f,&e);
                                        if (e.error != QJsonParseError::NoError)
                                        {
                                                VFS::ERROR( _reason = _path+" -- "+e.errorString() );
                                                VFS::ERROR( QString("offset: %1").arg(e.offset) );
                                                VFS::ERROR( QString(f) );
                                                _valid = false;
                                                return;
                                        }
 
                                        setData(d.object());
                                        _size = f.size();
                                }
                        }
                        else
                        {
                        //      QJsonObject data;
                        //      data["data"] = QString(f);
                        //      d.setObject(data);
 
                                setData(f);
                        }
 
                        _valid = true;
                        _dirty = false;
                }
                else
                {
                        //VFS::ERROR( _reason = QString("Unable to open '%1'.").arg(_path) );
                        _reason = QString("Unable to open '%1'.").arg(_path);
                        _valid = false;
                }
        }
}
 
VFS_HD_cache_entry::~VFS_HD_cache_entry()
{
        if (_debug)
                VFS::LOG( QString("Cache deleted: '%1'").arg(_path) );
 
        if (_dirty && _valid)
                flush();
}
 
void VFS_HD_cache_entry::modified(const QString &path)
{
        Q_UNUSED(path)
 
        //printf("MODIFIED: %s\n",qUtf8Printable(path));
 
        emit expired(this);
}
 
bool VFS_HD_cache_entry::valid(QString &reason)
{
        if (_valid)
                return _valid;
 
        if (!_info.exists() || !_info.isReadable())
        {
                //VFS::ERROR( _reason = QString("Illegal or unreadable path: %1").arg(_path) );
                _reason = QString("Illegal or unreadable path: %1").arg(_path);
                _valid = false;
        }
 
        return VFS_datastore_cache_entry::valid(reason);
}
 
void VFS_HD_cache_entry::flush()
{
        if (_debug)
                VFS::LOG( QString("Flushing '%1'").arg(_path) );
 
        if (!_dirty)
                return;
 
        if (_info.isDir())
        {       _dirty = false;
                //_reason = "Can't flush data to a directory or container: "+_path;
                return;
        }
 
        QFileInfo fi(_path);
 
        if (fi.lastModified() > _info.lastModified())
                VFS::WARN("File contents have changed since being cached.  Changes will be overwritten. ("+_path+")");
 
        QFile wfile(_path);
 
        if (wfile.open(QIODevice::WriteOnly))
        {
                QByteArray D;
 
                if (_raw)
                        //D = _data.object()["data"].toString().toLocal8Bit();
                        D = _rawData;
                else
                        D = _data.toJson();
 
                qint64 w = wfile.write(D);
 
                if (w != D.size())      //or == -1
                {
                        //issue a VFS::CRITICAL message if disk is full or other deep failure happens
                        VFS::CRITICAL( _reason = QString("Unable to write to %1... Is the disk full or a permission problem?").arg(_path) );
                        _dirty = true;
                }
                else
                {       //_size = wfile.size();
                        //_size = w;
                        _dirty = false;
                }
 
                wfile.close();
 
                _info.refresh();        //refresh the _info, like lastModified
        }
        else
        {
                _reason = QString("Can't open '%1' for writing.").arg(_path);
                _dirty = true;
        }
}
 
/*
VFS_HD_cache::VFS_HD_cache(int size)
: VFS_datastore_cache(size)
{
}
 
VFS_HD_cache::~VFS_HD_cache()
{
}
 
VFS_datastore_cache_entry *VFS_HD_cache::createEntry(QString p)
{
        return new VFS_HD_cache_entry(p);
}
*/
 
 
VFS_HD::VFS_HD(QString p, quint64 size, bool create, bool debug, int flushInterval, int expireInterval, bool raw, bool watch)
: VFS_datastore(size, debug)
, _path(p)
, _flushInterval(flushInterval)
, _expireInterval(expireInterval)
, _raw(raw)
, _watch(watch)
{
        QFileInfo i(_path);
        //_path = i.canonicalFilePath();        //clean the path
 
        if (i.isFile())
                VFS::WARN( QString("VFS_HD: '%1' is a file... VFS requests will probably fail!").arg(_path) );
 
        if (!i.isDir())
        {
                if (!create)
                        VFS::WARN( QString("VFS_HD: '%1' does not exist... VFS requests will fail!").arg(_path) );
                else
                {
                        QDir d = i.dir();
                        VFS::WARN( QString("VFS_HD: '%1' does not exist... Creating it.").arg(_path) );
                        if (!d.mkpath(_path))
                                VFS::WARN( QString("VFS_HD: '%1' doesn't exist and could not be created... VFS requests will fail!").arg(_path) );
                }
        }
}
 
VFS_HD::~VFS_HD()
{
}
 
 
QByteArray VFS_HD::icon()
{
        return VFS_icons::get("disk");
}
 
 
QString VFS_HD::reportDetails()
{
        QString s = VFS_datastore::reportDetails();
 
        QFileInfo i(_path);
 
        return "Path: "+_path+"\nReal Path: "+i.canonicalFilePath()+"\n"+s;
}
 
 
const QString VFS_HD::path()
{
        return _path;
}
 
 
void VFS_HD::ls(VFS_request *r)
{
        QMutexLocker _l(&_lock);
 
        //printf("VFS_HD::ls %s\n",qUtf8Printable(r->_initialPath));
 
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
 
        QFileInfo i(p);
 
        if (!i.exists())
        {
                if (r->_metadata.value("closest").toBool(false))        //if it is a call with 'closest' flag...
                {
                        //VFS::ERROR("LS CLOSEST 1");
                        //printf("PATH: %s\nPREFIX: %s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_prefixPath.join('/')));
 
                        QStringList parents = r->_path.split('/',Qt::SkipEmptyParts);
                        if (parents.length())
                        {
                                parents.pop_back();                                                             //climb up the path list to try to find something that does exist
                                VFS_request *s = r->getCallback(r->_origin);
                                s->_path = r->_prefixPath.join('/')+"/"+parents.join('/');
                                issueRequest(s);
                                return;
                        }
                        else
                        {       r->_reason = "Can't find a closest entry to list...  Already at the root of this node.";
                                r->_success = false;
                                //printf("METADATA:\n%s\n",qUtf8Printable( QJsonDocument::fromVariant(r->_metadata).toJson() ));
                                return;
                        }
                }
                else
                {       r->_reason = QString("Invalid path: %1\n").arg(p);
                        r->_success = false;
                        return;
                }
        }
 
        QDirIterator::IteratorFlags f = QDirIterator::FollowSymlinks;
        //if (recursive) f |= QDirIterator::Subdirectories;
 
        if (i.isFile())
        {
                if (r->_metadata.value("closest").toBool(false))                //if it's a call with 'closest' flag, but it's a file...
                {
                        //VFS::ERROR("LS CLOSEST 2");
                        //printf("PATH: %s\nPREFIX: %s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_prefixPath.join('/')));
 
                        QStringList parents = r->_path.split('/',Qt::SkipEmptyParts);
                        if (parents.length())
                        {
                                parents.pop_back();                                                             //climb up a level to try to find a container
                                VFS_request *s = r->getCallback(r->_origin);
                                s->_path = r->_prefixPath.join('/')+"/"+parents.join('/');
                                issueRequest(s);
                                return;
                        }
                        else
                        {       r->_reason = "Can't find a closest thing to list...  Already at the root of this node.";
                                r->_success = false;
                                //printf("METADATA:\n%s\n",qUtf8Printable( QJsonDocument::fromVariant(r->_metadata).toJson() ));
                                return;
                        }
                }
                else
                {       r->_reason = "Can't LS a file, directories/containers only.";
                        r->_success = false;
                        //printf("METADATA:\n%s\n",qUtf8Printable( QJsonDocument::fromVariant(r->_metadata).toJson() ));
                        return;
                }
        }
 
        //FIXME: arguably, this should be in remotoserver, or a more global place
        if (r->_metadata.value("closest").toBool(false))
                r->_metadata["closestContainer"] = r->_prefixPath.join('/') + "/" + r->_path;
 
        QString n,m;
        QJsonObject a;
        QDirIterator it(p,f);
        bool entriesExcluded = false;
        bool ignorePermissions = r->_metadata["ignorePermissions"].toBool(false);
 
        while (it.hasNext())
        {
                n = it.next();
                m = it.fileName();
                i = it.fileInfo();
                if (m!="." && m!="..")
                {
                        if (ignorePermissions || i.isReadable())        //check permission
                        {
                                //a.push_back( m+(i.isDir()?"/":"") );
                                a[m] = i.isDir();
                        }
                        else
                                entriesExcluded = true;
                }
        }
 
        if (entriesExcluded)
                r->_metadata["entriesExcluded"] = true;
 
        //printf("HD ls metadata: %s\n",qUtf8Printable( QJsonDocument(r->_metadata).toJson() ));
 
        if (r->_metadata.value("sequence").toBool(false))
                a = rutils::sequenceListing(a);
 
        //r->_data = QJsonDocument(a);
        r->_data.setObject(a);
        r->_success = true;
}
 
/*
VFS_node *VFS_HD::find(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        QString p = _path+"/"+r->_path;
        QFileInfo i(p);
        if (i.exists())
        {
                return this;
        }
 
        //if (allowNonExisting && path.length())
        //{
        //      QString newFile = path.takeLast();              //only allow one entry to be created.... not a whole path of directories
        //      QString sub = path.join("/");
        //      QString p = _path+"/"+sub;
        //      QFileInfo i(p);
        //      if (i.exists())
        //      {
        //              //VFS::WARN( QString("Returning path prefix for non-existent find request: '%1'").arg(p) );
        //              return this;
        //      }
        //}
 
        VFS::ERROR( QString("%1 Illegal path: '%2'").arg(className()).arg(p) );
 
        return 0;
}
*/
 
void VFS_HD::read(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
 
        bool creating = r->_metadata.value("createIfMissing").toBool(false);
        //bool container = r->_metadata.value("container",false).toBool();
        bool cache = r->_metadata.value("cache").toBool(true);
        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_HD.  Range will be ignored.",0,className());
        }
 
        //printf("VFS_HD::read RAW:%d PATH:'%s'\n",raw,qUtf8Printable(p));
 
        VFS_HD_cache_entry *en = static_cast<VFS_HD_cache_entry *>( _cache[r->_path] );
        //VFS_datastore_cache_entry *en = _cache[r->_path];
        if (!en)
        {
                //FIXME: check if _raw != raw ... it's possible that one call is for raw and another is for non-raw, but the cache won't be able to tell the difference
 
                en = new VFS_HD_cache_entry(p,_debug,_flushInterval,_expireInterval,false,false,raw,_watch);
                //printf("HD DATASTORE READ::CREATE: %p '%s'\n",this,qUtf8Printable(r->_path));
 
                if (!en->valid(r->_reason))
                {
                        delete en;
 
                        if (creating)
                        {
                                //printf("CREATE FROM READ: %s\n%s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_data.toJson()));
 
                                VFS_request::requestType t = r->_requestType;
                                r->_requestType = VFS_request::create;
                                write(r);
                                r->_requestType = t;
                                return;
                        }
 
                        r->_success = false;
                        return;
                }
 
                if (cache)
                if (!_cache.insert(r->_path,en))
                {       //printf( "%s\n", qUtf8Printable(QString("%1::read(): '%2' was too large to cache").arg(className()).arg(r->_path)) );
                        VFS::WARN( QString("%1::read(): '%2' was too large to cache").arg(className()).arg(r->_path), 9 );
                }
        }
 
        //printf("HD read metadata: %s\n",qUtf8Printable( QJsonDocument(r->_metadata).toJson() ));
 
        if (raw && !en->getRawData().isEmpty())
                r->_rawData = en->getRawData();
        else
        {
                r->_data = en->getData();
 
                if (r->_metadata.value("sequence").toBool(false) && en->_info.isDir())
                        r->_data.setObject( rutils::sequenceListing(r->_data.object()) );
        }
 
        if (!_cache.contains(r->_path))
                delete en;
 
        r->_success = true;
}
 
void VFS_HD::write(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
        bool creating = r->_requestType == VFS_request::create;
        bool container = r->_metadata.value("container").toBool(false);
        //bool raw = r->_metadata.value("raw").toBool(false) || _raw;
 
        VFS_datastore_cache_entry *en = _cache[r->_path];
        if (!en)
        {
                en = new VFS_HD_cache_entry(p,_debug,_flushInterval,_expireInterval,creating,container,_raw,_watch);
                //en->setData(r->_data.object());
                //printf("DATA:\n%s\n",qUtf8Printable(r->_data.toJson()));
 
                if (!en->valid(r->_reason))
                {       r->_success = false;
                        delete en;
                        //printf("INVALID DATASTORE ENTRY!\n");
                        //printf("REASON: %s\n",qUtf8Printable(r->_reason));
                        return;
                }
 
                r->_success = true;
 
                if (creating)
                {
                        if (_debug)
                                VFS::WARN( QString("About to create: '%1'").arg(p) );
 
                        //Create a diff for anything that is subscribed to the containing directory
                        //If container==true, the VFS_HD_cache_entry will create a directory.
 
                        QStringList dirs = r->_path.split("/",Qt::SkipEmptyParts);
                        QString newFile = dirs.takeLast();
                        QString dirPath = dirs.join("/");
 
                        QJsonObject o;
                        o[newFile] = container;
                        //FIXME: may need to write metadata here
                        VFS_request *c = createRequest(r->_requestType,dirPath,r->_user,QJsonDocument(o));
                        emit diff(this,c);
                        delete c;
 
                        if (!_cache.remove(dirPath))                                            //it will be re-created if needed
                        {       //printf("Unable to remove cache entry: %s\n",qUtf8Printable(dirPath));
                        }
                }
 
                //if (!_cache.insert(r->_path,en))
                //      VFS::WARN( QString("%1::write(): '%2' was too large to cache").arg(className()).arg(r->_path) );
        }
 
        if (!_raw)
                en->setData(r->_data.object());
        else
                en->setData(r->_rawData);
 
        //take() the cache entry if it exists
        if (_cache.contains(r->_path))
                _cache.take(r->_path);
 
        //re-insert the cache entry with the new size
        if (!_cache.insert(r->_path,en))
                VFS::WARN( QString("%1::write(): '%2' was too large to cache").arg(className()).arg(r->_path), 9 );
 
        //delete the cache entry if it didn't make it into the cache
        if (!_cache.contains(r->_path))
                delete en;
 
        r->_success = true;
 
        emit diff(this,r);
}
 
void VFS_HD::metadata(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        /*
        if (r->_path == "")
        {
                //FIXME: the VFS_HD node itself may have a root metadata component
        }
        else
        {
 
        }
        */
 
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
 
        //NOTE: should not do this, because it may be a raw read or need creation flags
        /*
        VFS_datastore_cache_entry *en = _cache[r->_path];
        if (!en)
        {
                en = new VFS_HD_cache_entry(p,_debug,_flushInterval,_expireInterval);
 
                if (!en->valid(r->_reason))
                {       r->_success = false;
                        delete en;
                        return;
                }
 
                if (!_cache.insert(r->_path,en))
                        VFS::WARN( QString("%1::metadata(): '%2' was too large to cache").arg(className()).arg(r->_path), 9 );
        }
        */
 
        QFileInfo fi(p);
        if (!fi.exists())
        {
                r->_reason = QString("Entry does not exist: '%1'.").arg(p);
                r->_success = false;
                return;
        }
 
        if (!fi.isReadable())
        {
                r->_reason = QString("Metadata permission denied: '%1'.").arg(p);
                r->_success = false;
                return;
        }
 
        if (r->_path == "")
                return VFS_datastore::metadata(r);
        else
                r->_metadata["icon"] = fi.isDir() ? VFS_icons::get("folder") : VFS_icons::get("document");
 
        if (_raw)
                r->_metadata["raw"] = true;
 
        QString t = VFS_node_type::getType(p,"");
 
        if (t == "")
        {
                QMimeType mime = _mimeDatabase.mimeTypeForFile(fi);
                t = mime.name();
 
                r->_metadata["mime"] = t;
                r->_metadata["type"] = mime.comment();
                r->_metadata["size"] = QString::number(fi.size());
                r->_metadata["mtime"] = QString::number(fi.lastModified().toSecsSinceEpoch());
        }
        else
        {       r->_metadata["type"] = t;
                r->_metadata["size"] = QString::number(fi.size());
                r->_metadata["mtime"] = QString::number(fi.lastModified().toSecsSinceEpoch());
        }
 
        r->_success = true;
}
 
void VFS_HD::submit(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
        bool creating = r->_metadata.value("createIfMissing").toBool(false);
        bool raw = r->_metadata.value("raw").toBool(false) || _raw;
 
        //FIXME: need to cover the case of attempting to submit to a directory, which should be illegal.
 
        VFS_datastore_cache_entry *en = _cache[r->_path];
        if (!en)
        {
                en = new VFS_HD_cache_entry(p,_debug,_flushInterval,_expireInterval,false,false,_raw,_watch);
 
                if (!en->valid(r->_reason))
                {
                        delete en;
 
                        if (creating)
                        {
                                //printf("CREATE FROM SUBMIT: %s\n%s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_data.toJson()));
 
                                VFS_request::requestType t = r->_requestType;
                                r->_requestType = VFS_request::create;
                                write(r);
                                r->_requestType = t;
                                return;
                        }
                        else
                        {
                                r->_success = false;
                                return;
                        }
                }
 
                if (!_cache.insert(r->_path,en))
                        VFS::WARN( QString("%1::submit(): '%2' was too large to cache").arg(className()).arg(r->_path), 9 );
        }
 
        if (!raw)
        {
                QJsonDocument fd = en->getData();
                QJsonObject o;
 
                if (r->_metadata.value("method").toString("json") == "delta")
                {
                        //o = applyDeltaDiff( fd.object(), r->_data.object(), "", r->_user );
                        QString s = applyDeltaDiff( fd.object()["data"].toString(), r->_data.object(), "", r->_user );
                        o["data"] = s;
                }
                else
                        o = applyJsonDiff( fd.object(), r->_data.object(), "", r->_user );
 
                en->setData(o);
 
                r->_success = true;
 
                emit diff(this,r);
        }
        else
        {
                QByteArray fd = en->getRawData();
                QJsonObject o;
 
                if (r->_metadata.value("method").toString("json") == "delta")
                {
                        QString s = applyDeltaDiff( QString::fromUtf8(fd), r->_data.object(), "", r->_user );
 
                        en->setData( s.toUtf8() );
 
                        r->_success = true;
 
                        emit diff(this,r);
                }
                else
                {       //o = applyJsonDiff( fd.object(), r->_data.object(), "", r->_user );
                        r->_success = false;
                        r->_reason = "Can't apply a json diff to _raw data.";
                }
        }
 
        if (!_cache.contains(r->_path))
                delete en;
}
 
void VFS_HD::rm(VFS_request *r)
{
        //check if path is empty... that means that this node is to be removed
        if (r->_path=="")
        {
                VFS_node::rm(r);
                return;
        }
 
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
 
        QFileInfo fi(p);
        bool s = false;
 
        _cache.remove(r->_path);
 
        if (fi.isDir())
        {
                QDir d(p);
                s = d.rmdir(p);
        }
        else
                s = QFile::remove(p);
 
        if (s)
        {
                QStringList dirs = r->_path.split("/",Qt::SkipEmptyParts);
                QString rmFile = dirs.takeLast();
                QString dirPath = dirs.join("/");
 
                _cache.remove(dirPath);                                                                         //it will be re-created if needed.
 
                QFileInfo info(rmFile);
                QJsonDocument diffData;
                QJsonObject o;
                o[ info.fileName() ] = QJsonValue::Null;                //null means remove
                diffData.setObject(o);
 
                unsubscribePath(r->_path);                                                                      //unsubscribePath on this path... it no longer exists!
 
                r->_data = diffData;
                r->_path = dirPath;
                r->_success = true;
 
                emit diff(this,r);
        }
        else
        {
                r->_reason = QString("Can't delete non-existent file and can't delete non-empty directory: '%1'").arg(p);
                r->_success = false;
        }
}
 
 
void VFS_HD::subscribe(VFS_request *r)
{
        //QString p = _path+"/"+r->_path;
        QString p = r->_path != "" ? _path+"/"+r->_path : _path;
 
        QFileInfo i(p);
 
        if (!i.exists())
        {
                if (r->_metadata["createIfMissing"].toBool())
                {
                        VFS_request::requestType t = r->_requestType;
                        r->_requestType = VFS_request::create;
                        write(r);
                        if (r->_success)
                        {       r->_requestType = t;
                                VFS_node::subscribe(r);
                        }
                }
                else
                {
                        r->_reason = QString("Can't subscribe to non-existent entry: '%1'").arg(p);
                        r->_success = false;
                }
        }
        else
                VFS_node::subscribe(r);
}
 
 
//FIXME: this needs a deeper look...
//it seems odd that this node and not others would need to use originPath
void VFS_HD::applyDiff(VFS_request *r)
{
        //QString p = r->_path;
        //r->_initialPath = r->_prefixPath.join('/')+"/"+r->_path;
        r->_path = r->_originPath;
 
        //printf("VFS_HD diff: %s %s\n",qUtf8Printable(r->_path),qUtf8Printable(r->_initialPath));
 
        submit(r);
 
        //r->_path = p;
 
        //VFS_node::applyDiff(r);
}
 
void VFS_HD::fetchRange(VFS_request *r)
{
        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();
 
        //printf("RANGE: %lld %lld\n",start,end);
 
        QString path = (r->_path != "") ? _path+"/"+r->_path : _path;
        QFileInfo info(path);
 
        if (!info.exists() || info.isDir())
        {
                r->_reason = "Can't fetch range on non-existent paths or directories: '"+path+"'";
                r->_success = false;
                return;
        }
 
        if (!info.isReadable())
        {
                r->_reason = "Fetch range read permission denied: '"+path+"'";
                r->_success = false;
                return;
        }
 
        QFile file(path);
        if (file.open(QFile::ReadOnly))
        {
                qint64 size = file.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_HD_MAX_READABLE)
                {
                        r->_reason = QString("Won't fetch range greater than %1 bytes.  Requested %2 bytes.").arg(VFS_HD_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 a file.  Requested bytes %1-%2 on '%3'").arg(start).arg(end).arg(path);
                        r->_success = false;
                        return;
                }
 
                qint64 bytes = end - start + 1;
 
                if (file.seek(start))
                {
                        QByteArray data = file.read(bytes);
 
                        if (data.length() != bytes)
                        {
                                r->_reason = QString("Could not read %1 bytes from '%2'.  Requested bytes %3-%4, but only %5 were returned.").arg(bytes).arg(path).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("Can't seek() to start value.  Requested bytes %1-%2 on '%3'").arg(start).arg(end).arg(path);
                        r->_success = false;
                        return;
                }
        }
        else
        {
                r->_reason = QString("Unable to open '%1'").arg(path);
                r->_success = false;
        }
}