VFS_node.cpp

Go to the documentation of this file.

 
#include <stdexcept>
 
#include <QMutableMapIterator>
#include <QDateTime>
#include <QTimer>
#include <QCoreApplication>
 
#include "VFS.h"
 
#include "VFS_node.h"
#include "VFS_auth/VFS_session.h"
//#include "VFS_acl.h"
#include "VFS_icons.h"
#include "utilities/rutils.h"
 
const char* VFS_request::requestTypeStrings[] =
{
        "none",
        "ls",
        "create",
        "rm",
        "read",
        "write",
        "metadata",
        "diff",
        "submit",
        "subscribe",
        "unsubscribe",
        "acl",
        "report",
        "requestlock",
        "releaselock",
        "code",
        "codeDirectory",
        nullptr
};
 
long VFS_request::_refcount = 0;
quint32 VFS_request::_sampleCount = 0;
QMutex VFS_request::_sampleLock(QMutex::Recursive);
int EXIT_DEPTH = 0;                                             //for pretty printing on exit
 
VFS_request::VFS_request(requestType type, VFS_node *origin, QString path, QString user, QJsonDocument data, QJsonObject metadata, bool dontDelete)
#ifdef DEBUG_DANGLING_REQUESTS
: QObject()
, _requestType(type)
#else
: _requestType(type)
#endif
, _origin(origin)
, _originPath("")
, _responder(nullptr)
, _initialPath(path)
, _prefixPath()
, _path(path)
, _callback(nullptr)
, _isCallback(false)
, _metadata(metadata)
, _data(data)
, _session(nullptr)
, _user(user)
, _success(false)               //default to no success
, _reason()
, _dontDelete(dontDelete)
{
        QMutexLocker l(&_sampleLock);
 
        _refcount++;
        _sampleCount++;
 
        //don't let an invalid path in no matter what
        _path = rutils::cleanPath(_path);
        _initialPath = rutils::cleanPath(_initialPath);
 
        #ifdef DEBUG_DANGLING_REQUESTS
        {
                QTimer::singleShot(10000, this, SLOT(timerEvent() ));
 
                //VFS_request *c = this;
                //QString p = this->_initialPath;
                //QTimer::singleShot(2000, [=] {
                //      printf("VFS_request timeout: %s %p\n",qUtf8Printable(p),this);
                //});
 
                /*
                _timer.setSingleShot(true);
                _timer.connect(&_timer,
                &QTimer::timeout,
                [=]() {
                        printf("VFS_request timeout: %s\n",qUtf8Printable(p));
                });
                _timer.start(2000);
                */
        }
        #endif
 
        _metadata["stamp"] = QDateTime::currentMSecsSinceEpoch();
 
        #ifdef DEBUG_DANGLING_REQUESTS
                printf("CREATE REFCOUNT: %ld (%p) %s %s\n",_refcount,this,qUtf8Printable(_user),qUtf8Printable(_path));
        #endif
}
 
 
VFS_request::VFS_request(const VFS_request &c)
#ifdef DEBUG_DANGLING_REQUESTS
: QObject()
, _requestType(c._requestType)
#else
: _requestType(c._requestType)
#endif
, _origin(c._origin)
, _originPath(c._originPath)
, _responder(c._responder)
, _initialPath(c._initialPath)
, _prefixPath(c._prefixPath)
, _path(c._path)
, _callback(c._callback)
, _isCallback(c._isCallback)
, _metadata(c._metadata)
, _data(c._data)
, _rawData(c._rawData)
, _session(c._session)
, _user(c._user)
, _success(c._success)
, _reason(c._reason)
, _notifyExceptions(c._notifyExceptions)
, _dontDelete(c._dontDelete)
{
        QMutexLocker l(&_sampleLock);
 
        _refcount++;
        _sampleCount++;
 
        //printf("VFS_request COPY CTOR!\n");
}
 
 
VFS_request::~VFS_request()
{
        QMutexLocker l(&_sampleLock);
 
        _refcount--;
        #ifdef DEBUG_DANGLING_REQUESTS
                printf("DELETE REFCOUNT: %ld (%p) %s %s\n",_refcount,this,qUtf8Printable(_user),qUtf8Printable(_path));
        #endif
 
//      if (_callback)
//              delete _callback;
}
 
 
void VFS_request::timerEvent(QTimerEvent *)
{
        printf("TIMEOUT: %s (%ld outstanding)!\n",requestTypeStrings[_requestType],_refcount);
        printf("%s %s\n",qUtf8Printable(_initialPath),qUtf8Printable(this->toJson(0,true,true)));
 
        //delete this;
        //printf("REFCOUNT: %ld (%lld)\n",_refcount,(quintptr)this);
}
 
 
quint32 VFS_request::getSample()
{
        QMutexLocker l(&_sampleLock);
 
        quint32 s = _sampleCount;
        _sampleCount = 0;
 
        return s;
}
 
 
void VFS_request::execute()
{
        //printf("VFS_request::execute %p %p\n",this,_origin);
 
        if (!_success)
        if (!(_metadata.contains("suppressError") && _metadata["suppressError"].toBool() == true))
        {
                if (_reason == "")
                        VFS::WARN( QString("VFS_request::execute %1 was not successful on '%2'").arg(requestTypeStrings[_requestType]).arg(_initialPath), 0, _user );
                else
                        VFS::WARN( _reason, 0, _user );
        }
}
 
 
void VFS_request::setCallback(VFS_request *c)
{
        if (_callback)
                VFS::WARN("WARN: setting callback when one is already present!\n");
 
        _callback = c;
        c->_isCallback = _callback ? true : false;
}
 
 
VFS_request *VFS_request::getCallback(VFS_node *receiver)
{
        VFS_request *r = new VFS_request(_requestType,receiver,_initialPath,_user);
        r->_data = _data;
        r->_metadata = _metadata;
        //r->_initialPath = _initialPath;
        r->_notifyExceptions = _notifyExceptions;
        r->_session = _session;
 
        r->setCallback(this);
 
        return r;
}
 
 
bool VFS_request::hasCallback()
{
        if (_callback)
                return true;
 
        return false;
}
 
 
void VFS_request::copyCallback(VFS_request *d)
{
        _metadata = d->_metadata;
        _data = d->_data;
        _rawData = d->_rawData;
        _session = d->_session;
 
        //_receiver = d->_receiver                              //NOT RECEIVER!  callback will already have a receiver
        //_origin = d->_origin                                  //NOT ORIGIN!
        //_callback = _callback                                 //DEFINITELY NOT!
        //_prefixPath = d->_prefixPath;                         //possibly, if we want to bypass a proxy requestor
        //_requestType = d->_requestType                        //NOT TYPE!  want to keep type of original caller
 
        //_path = d->_path;
        //_initialPath = "XXXXX";
 
        _success = d->_success;
 
        //printf("COPY CALLBACK:\n%s\n%s\n",qUtf8Printable(_reason),qUtf8Printable(d->_reason));
 
        _reason = d->_reason;
}
 
 
VFS_request *VFS_request::createDiff(VFS_node *origin, QString originPath)
{
        VFS_request *r = new VFS_request(VFS_request::diff,origin,_path,_user,_data,_metadata);
        r->_initialPath = _initialPath;
        //r->_prefixPath = _prefixPath;
        //r->_notifyExceptions = _notifyExceptions;             //we don't want this!  It needs to be a new request.
        r->_originPath = originPath;
 
        return r;
}
 
 
QByteArray VFS_request::toJson(postID id, bool ignoreSuccess, bool includeInitialPath)
{
        QJsonDocument d;
        QJsonObject o;
 
        //o["class"] = "VFS_request";
 
        o["id"] = id;
        o["type"] = _requestType;
        //o["originPath"] = _originPath;
        o["path"] = rutils::cleanPath(_path);
        o["user"] = _user;
 
        if (includeInitialPath)
                o["initialPath"] = _initialPath;
 
        //so we're not sending back the same data we received, or useless data if there's a failure
        if (_success || ignoreSuccess)
        {
                if (!_metadata.empty())
                        o["metadata"] = _metadata;
 
                if (!_data.isEmpty())
                        o["data"] = _data.object();
 
                if (!_rawData.isEmpty())
                        o["rawdata"] = QJsonValue::fromVariant( _rawData.toBase64() );
        }
        else
                o["reason"] = _reason;
 
        if (_session)
                o["session"] = QString("0x%1").arg((quintptr)_session, QT_POINTER_SIZE * 2, 16, QChar('0'));
 
        o["success"] = _success;
 
        d.setObject(o);
        return d.toJson();
}
 
 
void VFS_request::fromJsonObject(QJsonObject json, bool includeInitialPath)
{
        _requestType = static_cast<VFS_request::requestType>(json["type"].toInt());
        //_originPath = json["originPath"].toString();
        _path = json["path"].toString();
        _user = json["user"].toString();
 
        _success = json["success"].toBool();
        _reason = json["reason"].toString("");
 
        if (includeInitialPath)
                _initialPath = json["initialPath"].toString(_path);     //FIXME: there may be cases where this is needed, but for tcp_mount, you wouldn't want this.
 
        if (json.contains("data"))
        {
                if (json["data"].isArray())
                        _data = QJsonDocument(json["data"].toArray());          //FIXME: I don't think this case ever happens
                else
                        _data = QJsonDocument(json["data"].toObject());
        }
        else
                _data = QJsonDocument();
 
        if (json.contains("rawdata"))
        {
                _rawData = QByteArray::fromBase64( json["rawdata"].toString().toUtf8() );
        }
 
        _metadata = json["metadata"].toObject();
 
        //_session = ??
}
 
 
VFS_node::VFS_node()
: QObject()
, _lock(QMutex::Recursive)
{
        __addNode(this);
}
 
 
VFS_node::~VFS_node()
{
        QMutexLocker l(&_lock);
 
        __removeNode(this);
 
        unmount();
 
        //printf("node dtor: %s...\n",qUtf8Printable(className()));
        //VFS::LOG( QString("Deleting %1 (%2)").arg(className()).arg((quintptr)this) );
        //printf("VFS_node::~VFS_node: %p\n",this);
 
        QString p;
        VFS_node *o;
 
        int kc = 0;
 
        VFS_childrenConstIterator it;
 
        kc = 0;
        EXIT_DEPTH++;
        while(!_children.isEmpty())
        {
                it = _children.begin();
                p = it.key();
                o = it.value();
                remove(o);
                //remove(p);
                delete o;
                //o->deleteLater();
 
                if (kc++ > 10000)
                {       printf("Error: deleting too many children!\n");
                        return;
                        //throw("Deleting too many children!");
                }
        }
        EXIT_DEPTH--;
 
        //printf("node dtor 2...\n");
 
        emit finished(true);
}
 
 
QSet<VFS_node *> VFS_node::__allNodes;
QMutex VFS_node::__allNodesMutex(QMutex::Recursive);
 
 
bool VFS_node::__isNode(VFS_node *n)
{
        QMutexLocker l(&__allNodesMutex);
 
        return __allNodes.contains(n);
}
 
 
void VFS_node::__addNode(VFS_node *n)
{
        QMutexLocker l(&__allNodesMutex);
 
        __allNodes.insert(n);
}
 
 
bool VFS_node::__removeNode(VFS_node *n)
{
        if (__isNode(n))
        {
                QMutexLocker l(&__allNodesMutex);
                __allNodes.remove(n);
                return true;
        }
 
        return false;
}
 
 
QByteArray VFS_node::icon()
{
        //to be overridden by meaningful data in subclasses
 
        if (isContainer())
                return VFS_icons::get("folder");                //a default folder icon
 
        return VFS_icons::get("document");                      //a default document icon
}
 
 
void VFS_node::ls(VFS_request *r)
{
        QMutexLocker _l(&_lock);
 
        VFS_childrenIterator it;
        QJsonObject a;
 
        for (it=_children.begin();it!=_children.end();it++)
        {
                a[it.key()] = it.value()->isContainer();        //bool means whether it's a container.
        }
 
        r->_data = QJsonDocument(a);
        r->_success = true;
}
 
 
void VFS_node::read(VFS_request *r)
{
        if (isContainer() && r->_path == "")
        {
                if (!r->_metadata.contains("type"))
                        r->_metadata["type"] = "listing";
                ls(r);
                return;
        }
 
        //VFS::WARN( r->_reason = QString("%1::read() has no default meaning on non-containers.  Need to subclass?").arg(className()), 0, r->_user );
        r->_success = false;
}
 
 
void VFS_node::write(VFS_request *r)
{
        VFS::WARN( r->_reason = QString("%1::write() has no default meaning.  Need to subclass?").arg(className()), 0, r->_user );
        r->_success = false;
}
 
 
void VFS_node::metadata(VFS_request *r)
{
        r->_metadata["icon"] = QString(icon());
        //r->_metadata["class"] = className();
 
        r->_success = true;
}
 
 
void VFS_node::report(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        QJsonDocument d = r->_data;
        QJsonObject o;
 
        o["address"] = QString("0x%1").arg((quintptr)this, QT_POINTER_SIZE * 2, 16, QChar('0'));
        o["class"] = className();
        o["container"] = isContainer();
        o["thread"] = QString("0x%1").arg((quintptr)thread(), QT_POINTER_SIZE * 2, 16, QChar('0'));
        o["details"] = reportDetails();
        o["icon"] = QString(icon());
 
        metadata(r);                    //get the metadata
        //o["metadata"] = QJsonValue::fromVariant(r->_metadata);
 
        QJsonArray s;                   //subscriptions
        VFS_subscriptionType::iterator si = _subscribers.begin();
        while (si != _subscribers.end())
        {
                QString v = si.key();
                VFS_subscriptionOrigin so = si.value();
                VFS_subscriptionOrigin::iterator soi = so.begin();
 
                while(soi != so.end())
                {
                        QString vo = soi.key();
                        VFS_subscriptionCounter cv = soi.value();
                        VFS_subscriptionCounter::iterator ci = cv.begin();
 
                        while (ci != cv.end())
                        {
                                if (v!="")
                                {
                                        //s.append( QString("%1 %4 ← (%2) ← %3").arg((quintptr)ci.key()).arg(ci.value()).arg(v).arg(vo) );
                                        s.append( QString("%1 %4 ← (%2) ← %3").arg(QString("0x%1").arg((quintptr)ci.key(), QT_POINTER_SIZE * 2, 16, QChar('0'))).arg(ci.value()).arg(v).arg(vo) );
                                }
                                else
                                {
                                        //s.append( QString("%1 %4 ← (%2)").arg((quintptr)ci.key()).arg(ci.value()).arg(vo) );
                                        s.append( QString("%1 %4 ← (%2)").arg(QString("0x%1").arg((quintptr)ci.key(), QT_POINTER_SIZE * 2, 16, QChar('0'))).arg(ci.value()).arg(vo) );
                                }
 
                                ci++;
                        }
 
                        soi++;
                }
 
                si++;
        }
        o["subscriptions"] = s;
 
        VFS_node *child;
        bool childIsDir;
        QJsonObject c;                  //children
        VFS_childrenIterator ci = _children.begin();
        while (ci != _children.end())
        {       child = ci.value();
                //childIsDir = child->_children.size();
                childIsDir = child->isContainer() || child->_children.size();
                c[ci.key()+(childIsDir?"/":"")] = (qint64)((quintptr)child);
                ci++;
        }
        o["children"] = c;
 
        d.setObject(o);
 
        r->_data = d;
        r->_success = true;
}
 
 
QString VFS_node::reportDetails()
{
        return "";
}
 
 
void VFS_node::aclDefaults(VFS_request *r)
{
        r->_data.setObject( QJsonObject { { "default", true } } );
        r->_success = true;
}
 
 
void VFS_node::submit(VFS_request *r)
{
        VFS::WARN( r->_reason = QString("%1::submit() has no default meaning.  Need to subclass?").arg(className()), 0, r->_user );
 
        r->_success = true;
 
        emit diff(this,r);
}
 
 
void VFS_node::rm(VFS_request *r)
{
        if (r->_path == "" && _children.count()==0)
        {
                emit finished(true);                                    //the parent listens for this
                r->_success = true;
 
                //unsubscribePath(r->_path);                            //unsubscribePath on this path... it no longer exists!
 
                return;
        }
 
        VFS::WARN( r->_reason = QString("%1::rm() cannot delete non-empty directory or bad path.").arg(className()), 0, r->_user );
        r->_success = false;
}
 
 
QString VFS_node::code(QString nodename, QString libname, QString &error)
{
        /*
           A well-behaved node/library would probably load these from a qrc file or
           directly off the disk.
 
           Loading directly off disk is a nice idea, because the author could change
           source js files without recompiling.
 
           But, placing them directly in source code or qrc would obfuscate the code
           from those poking around, and also encapsulate them in a lib
         */
 
        error = QString("Cannot load library: %1:%2").arg(nodename).arg(libname);
 
        return "";
}
 
 
void VFS_node::requestLock(VFS_request *r)
{
        VFS::WARN( r->_reason = QString("%1::requestLock() has no default meaning.  Need to subclass?").arg(className()), 0, r->_user );
 
        r->_success = false;
}
 
 
void VFS_node::releaseLock(VFS_request *r)
{
        VFS::WARN( r->_reason = QString("%1::releaseLock() has no default meaning.  Need to subclass?").arg(className()), 0, r->_user );
 
        r->_success = false;
}
 
 
VFS_node *VFS_node::find(QString path)
{
        VFS_request r(VFS_request::none,nullptr,path);
        r._metadata["suppressError"] = true;
        return find( &r );
}
 
 
VFS_node *VFS_node::find(VFS_request *r)
{
        QStringList pl = r->_path.split("/",Qt::SkipEmptyParts);
 
        if (pl.isEmpty())
                return this;
 
        QMutexLocker l(&_lock);
 
        QString p = pl.takeFirst();
        if (_children.contains(p))
        {
                r->_path = pl.join("/");
                r->_prefixPath += p;
                return _children[p]->find(r);
        }
 
        if (r->_requestType != VFS_request::unsubscribe)
        if (!r->_metadata.value("suppressError").toBool(false))
        {       //r->_reason = QString("%1 non-existent path: '%2' (%3 on '%4' => '%5') %6 %7 %8").arg(className()).arg(p).arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_prefixPath.join("/")).arg(r->_initialPath).arg((quintptr)r,0,16).arg((quintptr)r->_origin,0,16).arg(qUtf8Printable(r->_data.toJson()));
                r->_reason = QString("%1 non-existent path: '%2' (%3 on '%4' => '%5')").arg(className()).arg(p).arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_prefixPath.join("/")).arg(r->_initialPath);
                //printf("JSON: %s\n",qUtf8Printable(r->toJson(0,true,true)));
        }
 
        r->_success = false;
 
        return nullptr;
}
 
 
void VFS_node::subscribe(VFS_request *r)
{
        VFS_node *subscriber = r->_origin;
        QString subscriberSubpath = rutils::cleanPath( r->_originPath );
 
        //FIXME: check that this does not create a circular subscription reference!
 
        if (__isNode(subscriber))
        {
                //only lock until _subscribers is updated
                {
                        QMutexLocker l(&_lock);
 
                        int count = r->_metadata.value("subscriptions").toInt(1);
                        _subscribers[r->_path][subscriberSubpath][subscriber]+=count;                                                   //will create default/empty values as needed.
                }
 
                connect( subscriber, SIGNAL(unmounted(VFS_node *)), this, SLOT(unsubscribeAll(VFS_node *)), Qt::UniqueConnection );
 
                if (!r->_isCallback)
                {
                        metadata(r);
                        if (!r->_success) return;
                }
 
                if (!r->_metadata.contains("__SUBSCRIBE_ONLY__") || r->_metadata["__SUBSCRIBE_ONLY__"].toBool()!=true)
                if (!r->_isCallback)
                {
                        read(r);
                        if (!r->_success) return;
                }
                //else
                //      printf("WAS CALLBACK!\n");
 
                //r->_success = true;
 
                //VFS::LOG( QString("%1 subscribe on %2 (%3->%4)").arg(className()).arg(r->_path).arg((quintptr)subscriber).arg(subscriber->className()) );
        }
        else
                VFS::ERROR( r->_reason = "Cannot subscribe null subscriber.", 0, r->_user );
}
 
 
void VFS_node::unsubscribe(VFS_request *r)
{
        QMutexLocker l(&_lock);
 
        VFS_node *subscriber = r->_origin;
 
        if (subscriber)
        {
                //printf("Unsubscribing: %s\n",qUtf8Printable(r->_path));
                if (_subscribers.contains(r->_path) && _subscribers.value(r->_path).value(r->_originPath).contains(subscriber))
                {
                        int count = r->_metadata.value("unsubscriptions").toInt(1);
 
                        if ((_subscribers[r->_path][r->_originPath][subscriber]-=count) <= 0)           //decrement the count
                        {       _subscribers[r->_path][r->_originPath].remove(subscriber);              //remove if zero
                                //printf("REMOVED 1: %d\n",count);
                        }
 
                        if (!_subscribers.value(r->_path).value(r->_originPath).size())
                        {       _subscribers[r->_path].remove(r->_originPath);
                                //printf("REMOVED 2\n");
                        }
 
                        if (!_subscribers.value(r->_path).size())                                       //clean up the path part
                        {       _subscribers.remove(r->_path);                                          //remove if empty
                                //printf("REMOVED 3\n");
                        }
 
                        int i=0;
                        //Check if no subscriptions are left for subscriber
                        //recurse through all subscription paths to count subscriber references
                        VFS_subscriptionType::iterator it = _subscribers.begin();
                        while (it != _subscribers.end())
                        {
                                VFS_subscriptionOrigin o = it.value();
                                VFS_subscriptionOrigin::iterator ito = o.begin();
                                while (ito != o.end())
                                {
                                        i+= ito.value().count(subscriber);
                                        ito++;
                                }
 
                                it++;
                        }
 
                        if (i==0)
                        {       disconnect( subscriber, SIGNAL(unmounted(VFS_node *)), this, SLOT(unsubscribeAll(VFS_node *)) );
                                //disconnect( this, SIGNAL(diff(VFS_request*)), subscriber, SLOT(applyDiff(VFS_request*)) );
                        }
 
                        r->_success = true;
                }
                else
                {       //r->_reason = QString("%1 Unable to unsubscribe from '%2'... was it subscribed?").arg(className()).arg(r->_path);
                        r->_success = true;     //consider all properly-formed unsubscribe operations to be a success, regardless of if a subscription existed.
                }
        }
        else
        {       //VFS::ERROR( r->_reason = "Unable to unsubscribe without a subscriber...", 0, r->_user );
                r->_reason = "Unable to unsubscribe without a subscriber...";
        }
}
 
 
void VFS_node::unsubscribeAll(VFS_node *subscriber)
{
        QMutexLocker l(&_lock);
 
        int c;
 
        QMutableMapIterator<QString, VFS_subscriptionOrigin > ito(_subscribers);
        while (ito.hasNext())
        {
                ito.next();
 
                QMutableMapIterator<QString, VFS_subscriptionCounter > it(ito.value());
                while (it.hasNext())
                {
                        it.next();
 
                        c=it.value().remove(subscriber);
                        //if ((c=it.value().remove(subscriber)))
                        //{     VFS::LOG( QString("unsubscribeAll removed '%1' (%2)").arg(it.key()).arg(c), 9 );
                        //}
 
                        if (!it.value().size())
                                it.remove();
                                //_subscribers.remove(it.key())
 
                        if (c)
                                VFS::LOG( QString("unsubscribeAll removed '%1' %2 (%3)").arg(ito.key()).arg(className()).arg(c), 9 );
                }
 
                if (!ito.value().size())
                        ito.remove();
        }
 
        //rely on the VFS_node's destructor to do the cleanup...
        //disconnect( subscriber, SIGNAL(unmounted(VFS_node *)), this, SLOT(unsubscribeAll(VFS_node *)) );
}
 
 
void VFS_node::unsubscribePath(QString path)
{
        QMutexLocker l(&_lock);
 
        if (_subscribers.contains(path))
        {
                VFS_subscriptionOrigin so = _subscribers[path];
                VFS_subscriptionOrigin::iterator i = so.begin();
                while (i != so.end())
                {
                        QString k = i.key();
                        VFS_subscriptionCounter v = i.value();
                        int c = 0;
                        VFS_subscriptionCounter::iterator ci = v.begin();
                        while (ci != v.end())
                        {       c += ci.value();
                                ci++;
                        }
 
                        //l.unlock();   //don't emit when locked
 
                        //printf("emit null unsubscribe diff: %s / %s / %d\n",qUtf8Printable(path),qUtf8Printable(k),c);
                        VFS_request *r = createRequest(VFS_request::none,path,"server");        //emit a null diff to notify subscribers of the removal
                        emit diff(this,r);
                        delete r;
 
                        //l.relock();   //but re-lock for the next loop
 
                        i++;
                }
        }
 
        if (!_subscribers.remove(path))
        {
                //FIXME: seems like we would want this message, except in the case of rm() it will probably be for a non-existent path
                //VFS::ERROR( QString("%1 unable to unsubscribePath from '%2'... was it subscribed?").arg(className()).arg(path) );
 
                /*
                VFS::WARN( QString("%1 unable to unsubscribePath from '%2'... was it subscribed?").arg(className()).arg(path) );
                VFS_subscriptionIterator si = _subscribers.begin();
                while (si != _subscribers.end())
                {
                        QString v = si.key();
                        VFS_subscriptionCounter cv = si.value();
                        VFS_subscriptionCounterIterator ci = cv.begin();
 
                        while (ci != cv.end())
                        {
                                if (v!="")
                                        VFS::WARN( QString("%2 ← (%3) ← %1").arg(v).arg((quintptr)ci.key()).arg(ci.value()) );
                                else
                                        VFS::WARN( QString("%1 ← (%2)").arg((quintptr)ci.key()).arg(ci.value()) );
 
                                ci++;
                        }
 
                        si++;
                }
                */
        }
}
 
 
void VFS_node::applyDiff(VFS_request *r)
{
        //VFS::WARN( QString("%1::applyDiff() has no default meaning.  Need to subclass?").arg(className()), 0, r->_user );
 
        //notifySubscribers(this,r);            //This is already linked via connect() to the diff() signal.
        emit diff(this,r);
 
        r->_success = true;
}
 
 
void VFS_node::notifySubscribers(VFS_node *origin, VFS_request *t)
{
        QMutexLocker lk(&_lock);
 
        //no need to send empty data around
        if (t->_data.isEmpty() && t->_metadata.isEmpty())
        {       printf("SKIPPING notify on empty request: %s\n",qUtf8Printable(t->_path));
                return;
        }
 
        VFS_request *r;
        VFS_subscriptionOrigin origins = _subscribers.value(t->_path);          //will return empty QMap if non-existant
 
        foreach(QString o, origins.keys())
        {
                VFS_subscriptionCounter subscribers = origins.value(o);
 
                foreach(VFS_node *s,subscribers.keys())
                {
                        //printf("   CHECK: %p \"%s\"\n",s,qUtf8Printable(t->_initialPath));
                        //if (true)
                        if ( ! t->_notifyExceptions.contains( notifyException(s,t->_initialPath) ) )
                        {
                                //printf( "    EMIT: %p \"%s\" \"%s\"\n", s, qUtf8Printable(t->_path), qUtf8Printable( t->_initialPath ) );
 
                                QMutexLocker l(&VFS_node::__allNodesMutex);
                                if (__isNode(s))
                                {
                                        //printf("  Origin: %s %s %s\n",qUtf8Printable(o),qUtf8Printable(t->_path),qUtf8Printable(t->_initialPath));
 
                        //              r = new VFS_request(VFS_request::diff,origin,t->_path,t->_user,t->_data,t->_metadata);
                        //              r->_initialPath = t->_initialPath;
                        //              //r->_prefixPath = t->_prefixPath;
                        //              //r->_notifyExceptions = t->_notifyExceptions;          //we don't want this!  It needs to be a new request.
                        //              r->_originPath = o;
 
                                        r = t->createDiff(origin,o);
 
                                        //may want to unlock lk now
                                        //lk.unlock();
 
                                        QMetaObject::invokeMethod( s, "executeRequest", Qt::AutoConnection, Q_ARG(VFS_request*, r) );
                                        //QMetaObject::invokeMethod( s, "executeRequest", Qt::QueuedConnection, Q_ARG(VFS_request*, r) );
 
                                        //...and relock lk here
                                        //lk.relock();
                                }
                                //else
                                //      printf("  Not a node!\n");
                        }
                        else
                        {       //printf( "    SKIP: %p %s \"%s\"\n", s, qUtf8Printable(t->_path), qUtf8Printable( t->_initialPath ) );
                        }
                }
        }
}
 
 
VFS_node *VFS_node::append(QString name, VFS_node *node, bool containerCheck, QString user)
{
        if (containerCheck)
        if (!isContainer())
        {       VFS::ERROR( QString("Cannot append '%1' to a %2 node where isContainer() is false.  Not appending.").arg(name).arg(className()) );
                return nullptr;
        }
 
        if (!validChildName(name))
        {       VFS::ERROR( QString("Node name is invalid: '%1'.  Not appending.").arg(name) );
                return nullptr;
        }
 
        if (_children.contains(name))
        {       VFS::ERROR( QString("Child with name '%1' already exists.  Not appending.").arg(name) );
                return nullptr;
        }
 
        if (!node)
        {       VFS::ERROR( QString("Cannot append null node '%1'").arg(name) );
                return nullptr;
        }
 
        //new context for the lock to expire...
        //we want this to be unlocked when diff() is emitted because we don't know what thread we're in
        {
                connect(node, SIGNAL(finished(bool)), this, SLOT(remove(bool)));
 
                QMutexLocker l(&_lock);
 
                _children[name] = node->mount();
        }
 
        VFS::LOG( QString("Appended node '%1'").arg(name), 8, user );
 
        //do ACL check for defaults here
        /*
        if (VFS_acl::hasRegisteredDefaults( node->className() ))
        {
                printf("Would add features to %s node\n", qUtf8Printable(node->className()));
                //VFS_acl::includeACLDefaults(env["vfscwd"].toString(), node->className());
        }
        */
 
        QJsonObject d;
        d[name] = node->isContainer();
        VFS_request r(VFS_request::diff,this,"",user);
        r._data = QJsonDocument(d);
        emit diff(this,&r);
 
        return node;
}
 
 
void VFS_node::remove(bool andDelete)
{
        VFS_node *node = dynamic_cast< VFS_node * >(sender());
        //VFS_node *node = qobject_cast< VFS_node * >(sender());
 
        if (node)
        {
                remove();
 
                if (andDelete)
                        //delete node;
                        node->deleteLater();
        }
        else
                VFS::WARN( QString("%1 No sender found... unable to remove()").arg(className()) );
}
 
 
void VFS_node::remove(VFS_node *node, QString *rname, QString user)
{
        //printf("REMOVE: %p\n",this);
 
        if (!node)
                node = dynamic_cast< VFS_node * >(sender());
 
        //printf("REMOVE: %p %p\n",node,this);
 
        if (node)
        {
                QMutexLocker l(&_lock);
 
                QString name = _children.key(node,"");
 
                if (_children.contains(name))
                {
                        if (rname) (*rname) = name;
 
                        VFS_node *node = _children.take(name);
 
                        disconnect(node, SIGNAL(finished(bool)), this, SLOT(remove(bool)));
 
                        node->unmount();
 
                        VFS::LOG( QString("Removing node%2'%1'").arg(name).arg(' ',(EXIT_DEPTH-1)*3), 8, user );
 
                        l.unlock();             //want to release this before the diff is emitted
 
                        //VFS_request r(VFS_request::diff,this,"","server");
                        QJsonObject d;
                        d[name] = QJsonValue::Null;
                        VFS_request r(VFS_request::diff,this,"",user);
                        r._data = QJsonDocument(d);
                        emit diff(this,&r);
                }
                else
                        VFS::WARN( QString("Unable to unmount node '%1'").arg(name) );
        }
        else
        {       VFS::WARN( QString("Unable to unmount null node") );
                //emit finished(true);
        }
}
 
 
VFS_node *VFS_node::mount()
{
        connect(        this, SIGNAL(diff(VFS_node *,VFS_request *)),
                        this, SLOT(notifySubscribers(VFS_node *,VFS_request *)) );
 
        //setParent(_mount);
 
        emit mounted();
 
        return this;
}
 
 
VFS_node *VFS_node::unmount()
{
        disconnect(     this, SIGNAL(diff(VFS_node *,VFS_request *)),
                        this, SLOT(notifySubscribers(VFS_node *,VFS_request *)) );
 
        emit unmounted(this);
 
        //disconnect(   this, SIGNAL(unmounted(VFS_node *)));
 
        return this;
}
 
 
void VFS_node::subtreeRequest(VFS_request *t)
{
        //QMutexLocker l(&_lock);
 
        VFS_node *n = find(t);
 
        if (n)
        {
                n->executeRequest(t);
        }
        else
        {
                if (t->_requestType != VFS_request::unsubscribe)
                {
                        //if (!t->_session || __isNode(t->_session))
                        if (!(t->_metadata.contains("suppressError") && t->_metadata["suppressError"].toBool(false) == true))
                        {
                                if (t->_reason == "")
                                        t->_reason = QString("%1 request on path '%2' could not be found.").arg(VFS_request::requestTypeStrings[t->_requestType]).arg(t->_initialPath);
                                //this causes duplicate warning messages
                                //VFS::WARN( t->_reason, 0, t->_user );
                        }
                }
 
                t->_success = false;
 
                issueResponse(t);
        }
}
 
 
void VFS_node::executeRequest(VFS_request *t)
{
        //QMutexLocker l(&_lock);
 
        try
        {
                switch(t->_requestType)
                {
                        case VFS_request::none:                 VFS::WARN( "Cannot execute request on VFS_request::none." );    break;
 
                        case VFS_request::ls:                   ls(t);                  break;
                        case VFS_request::create:               write(t);               break;
                        case VFS_request::rm:                   rm(t);                  break;
                        case VFS_request::read:                 read(t);                break;
                        case VFS_request::write:                write(t);               break;
                        case VFS_request::metadata:             metadata(t);            break;
                        case VFS_request::diff:                 applyDiff(t);           break;
                        case VFS_request::submit:               submit(t);              break;
                        case VFS_request::subscribe:            subscribe(t);           break;
                        case VFS_request::unsubscribe:          unsubscribe(t);         break;
                        case VFS_request::acl:                  aclDefaults(t);         break;
                        case VFS_request::report:               report(t);              break;
                        case VFS_request::requestlock:          requestLock(t);         break;
                        case VFS_request::releaselock:          releaseLock(t);         break;
 
                        default:                                VFS::WARN( QString("Unknown requestType: %1").arg(t->_requestType) );           break;
                }
        }
        catch (std::exception &e)
        {
                VFS::ERROR( QString("executeRequest() caught exception for %1 operation: %2").arg(VFS_request::requestTypeStrings[t->_requestType]).arg(e.what()), 0, className());
                t->_success = false;
                exit(3);
        }
        catch (...)
        {
                VFS::ERROR( QString("executeRequest() caught exception for %1 operation").arg(VFS_request::requestTypeStrings[t->_requestType]), 0, className());
                t->_success = false;
                exit(3);
        }
 
        if (!t->_isCallback)
                issueResponse(t);
}
 
 
void VFS_node::receiveResponse(VFS_request *t)
{
        //printf("VFS_node::receiveResponse %p %s %s\n",t,qUtf8Printable(t->_initialPath),qUtf8Printable(t->_data.object()["data"].toString()));
 
        if (t)
        {
                t->execute();
 
                if (t->_callback)
                {       //printf("Issuing response to callback on '%s'.\n",qUtf8Printable(t->_initialPath));
                        t->_callback->copyCallback(t);
                        issueResponse(t->_callback);
                }
 
                if (!t->_dontDelete)
                        delete t;
        }
        else
                VFS::ERROR( "receiveResponse() called with null request." );
}
 
 
VFS_request *VFS_node::createRequest(VFS_request::requestType type, QString path, QString user, QJsonDocument data, QJsonObject metadata, bool dontDelete)
{
        VFS_request *r = new VFS_request(type,this,path,user,data,metadata,dontDelete);
        return r;
}
 
 
void VFS_node::issueRequest(VFS_request *t)
{
        issueRequest(VFS::root(),t);
}
 
 
void VFS_node::issueRequest( VFS_node *target, VFS_request *t)
{
        QMutexLocker l(&VFS_node::__allNodesMutex);
        if (__isNode(target))
        {
                QMetaObject::invokeMethod(target,"subtreeRequest",Qt::AutoConnection,Q_ARG(VFS_request*, t));
                //QMetaObject::invokeMethod(target,"subtreeRequest",Qt::QueuedConnection,Q_ARG(VFS_request*, t));
        }
        else
        {       printf("issueRequest() called without a node.  Deleting request.\n");
                delete t;
        }
}
 
 
void VFS_node::issueResponse( VFS_request *t )
{
        //QMutexLocker l(&_lock);
 
        if (t && t->_origin)
        {
                VFS_node *target = t->_origin;
 
                t->_responder = this;
 
                QMutexLocker l(&VFS_node::__allNodesMutex);
                if (__isNode(target))
                {
                        QMetaObject::invokeMethod(target,"receiveResponse",Qt::AutoConnection,Q_ARG(VFS_request*, t));
                        //QMetaObject::invokeMethod(target,"receiveResponse",Qt::QueuedConnection,Q_ARG(VFS_request*, t));
                }
                else
                {       //printf("RESPONSE TARGET IS NOT A NODE for %s... deleting request.\n",qUtf8Printable(t->_initialPath));
                        delete t;
                }
        }
        else
        {       VFS::ERROR( "issueResponse() called with null request or no receiver.  Deleting request." );
                delete t;
        }
}
 
 
bool VFS_node::isContainer()
{
        return true;
}
 
 
QString VFS_node::className()
{
        return metaObject()->className();
}
 
 
QString VFS_node::uniqueChildName(QString name)
{
        QMutexLocker l(&_lock);
 
        int i=1;
        QString temp = name;
 
        //FIXME: this should not return a name that does not pass validChildName(name)
        while (_children.contains(temp))
                temp = QString("%1-%2").arg(name).arg(i++);
 
        return temp;
}
 
 
VFS_node *VFS_node::findChildWithName(QString name)
{
        QMutexLocker l(&_lock);
 
        return _children.value(name,nullptr);
}
 
 
bool VFS_node::validChildName(QString name)
{
        if (name.trimmed().isEmpty())           return false;   //can't be empty
        if (name.contains(QRegExp("[/]")))      return false;   //bad chars.  Really the only bad one is a slash.
        if (name.trimmed() != name)             return false;   //can't start or end with whitespace; that's just dumb
 
        return true;
}
 
 
void VFS_node::addACLDefault( QJsonObject &acl, bool value, QString description )
{
        acl["default"] = value;
        if (!description.isEmpty())
                acl["description"] = description;
}
 
 
void VFS_node::addACLGroup( QJsonObject &acl, QString group, bool value )
{
        QJsonObject g = acl["groups"].toObject();
        g[group] = value;
        acl["groups"] = g;
}
 
 
void VFS_node::addACLUser( QJsonObject &acl, QString user, bool value )
{
        QJsonObject u = acl["users"].toObject();
        u[user] = value;
        acl["users"] = u;
}
 
 
void VFS_node::addACLFeature( QJsonObject &acl, QString feature, bool value, QString description )
{
        QJsonObject fs = acl["features"].toObject();
        QJsonObject f = fs[feature].toObject();
        f["default"] = value;
        if (!description.isEmpty())
                f["description"] = description;
        fs[feature] = f;
        acl["features"] = fs;
}
 
 
void VFS_node::addACLFeatureGroup( QJsonObject &acl, QString feature, QString group, bool value )
{
        QJsonObject fs = acl["features"].toObject();
        QJsonObject f = fs[feature].toObject();
        QJsonObject g = f["groups"].toObject();
        g[group] = value;
        f["groups"] = g;
        fs[feature] = f;
        acl["features"] = fs;
}
 
 
void VFS_node::addACLFeatureUser( QJsonObject &acl, QString feature, QString user, bool value )
{
        QJsonObject fs = acl["features"].toObject();
        QJsonObject f = fs[feature].toObject();
        QJsonObject u = f["users"].toObject();
        u[user] = value;
        f["users"] = u;
        fs[feature] = f;
        acl["features"] = fs;
}