VFS_remotoserver.cpp

Go to the documentation of this file.

#include <QDateTime>
#include <QProcessEnvironment>
#include <QHostInfo>
#include <QCoreApplication>
#include <QFile>
#include <QFileInfo>
 
#include "VFS_remotoserver.h"
 
#include "defines.h"
#include "utilities/rutils.h"
 
#include "VFS.h"
#include "VFS_creator.h"
 
int VFS_remotoserver::count = 0;
 
VFS_remotoserver::VFS_remotoserver(quint16 port, QString authPaths, QString sessions, QHostAddress addr, QWebSocketServer::SslMode ssl, QString sslCertPath, QString sslKeyPath)
: VFS_websocket_server(port,authPaths,sessions,addr,ssl,sslCertPath,sslKeyPath)
{
        count++;
}
 
VFS_remotoserver::~VFS_remotoserver()
{
}
 
void VFS_remotoserver::clientBinaryMessage(QByteArray message)
{
        VFS_remotoserver_client *s = dynamic_cast< VFS_remotoserver_client * >(sender());
 
        //VFS::WARN("Binary message received on websocket...\n");
        //printf("MESSAGE:\n%s\n",qUtf8Printable(message));
 
        if (s)
        {
                s->receive(message);
        }
        else
                VFS::ERROR( QString("%1 clientBinaryMessage() called without client!").arg(className()) );
}
 
void VFS_remotoserver::clientTextMessage(QString message)
{
        VFS_remotoserver_client *s = dynamic_cast< VFS_remotoserver_client * >(sender());
 
        //printf("MESSAGE:\n%s\n",qUtf8Printable(message));
 
        if (s)
        {
                s->receive(message.toUtf8());
        }
        else
                VFS::ERROR( QString("%1 clientTextMessage() called without client!").arg(className()) );
}
 
VFS_websocket_client *VFS_remotoserver::createWebsocketClient(QWebSocket *s)
{
        return new VFS_remotoserver_client(s,this);
}
 
QString VFS_remotoserver::reportDetails()
{
        QString s = QString("port: %1\nsessions: %2").arg(_port).arg(_sessionsPath);
 
        return s;
}
 
 
VFS_remotoserver_client::VFS_remotoserver_client(QWebSocket *socket, VFS_websocket_server *server)
: VFS_websocket_client(socket,server)
, _session(nullptr)
, _user("unknownuser")
{
}
 
VFS_remotoserver_client::~VFS_remotoserver_client()
{
        //printf("DELETE RMO CLIENT\n");
}
 
VFS_request *VFS_remotoserver_client::createRequest(VFS_request::requestType type, QString path, QString user, QJsonDocument data, QJsonObject metadata, bool dontDelete)
{
        Q_UNUSED(dontDelete)
 
        VFS_remotoserver_request *r = new VFS_remotoserver_request(type,this,path,user,data,metadata,false);
 
        r->_session = _session;
 
        return r;
}
 
void VFS_remotoserver_client::applyDiff(VFS_request *t)
{
        QMutexLocker l(&_lock);
 
        VFS_node *source = t->_origin;
 
        //printf("INITIAL: %s\n",qUtf8Printable(t->_initialPath));
        //if ( ! t->_notifyExceptions.contains( notifyException(source,t->_initialPath) ) )
        //{
                if (_sourcePathMap.contains(source))
                {
                        QString path = rutils::cleanPath( _sourcePathMap.value(source)+"/"+t->_path );
 
                        writeUIDiff(path,t->_data,t->_user);
                }
                else
                {       VFS::ERROR( QString("Could not find _sourcePathMap reference for 0x%1 (%2).  Not applying diff for '%3'").arg((quintptr)source, QT_POINTER_SIZE * 2, 16, QChar('0')).arg(source->className()).arg(t->_initialPath), 0, t->_user );
                        //printf("NO SOURCEPATHMAP:%s\n",qUtf8Printable(t->toJson(0,true,true)));
                        t->_success = false;
                        return;
                }
        //}
        //else
        //      printf("Skipped due to exception!\n");
 
        t->_success = true;
 
        VFS_node::applyDiff(t);
}
 
QJsonDocument VFS_remotoserver_client::receive(QByteArray data)
{
        //printf("%s\n", qUtf8Printable( QString("Received Remotoserver Message:\n%1").arg(data.data()) ) );
 
        QJsonDocument d = VFS_websocket_client::receive(data);
        if (d.isNull())
                return d;
 
        //QMutexLocker l(&_lock);
 
        QJsonObject dob = d.object();
        QJsonObject attrs = dob["attributes"].toObject();
        QString tag = dob["command"].toString();
 
        if (!_authenticated || !_authorized)
        {       authenticate(d);
                return d;
        }
 
        if (tag == "ping")
        {
                VFS::LOG( QString("ping"), 9, _user );
 
                writeText( "{ \"command\":\"pong\" }" );
                return d;
        }
 
        if (tag == "create")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        VFS_request *r=nullptr;
 
                        QJsonValue v = i.value();
                        if (v.isBool())
                        {
                                if (v.toBool()==true)
                                {
                                        QJsonObject m;
                                        m["container"] = true;
                                        r = createRequest(VFS_request::create, path, _user, QJsonDocument(), m );
                                }
                                else
                                {
                                        VFS::ERROR( QString("Useless create request on '%1'.  Value was false." ).arg(path), 5, _user );
                                }
                        }
                        else
                        {
                                r = createRequest(VFS_request::create, path, _user, QJsonDocument(i.value().toObject()) );
                        }
 
                        //add _notifyExceptions entries for the new file and its containing folder.
                //FIXME: Disabled notifyException for create... does it need to be enabled?
                //      QStringList dirs = path.split("/",Qt::SkipEmptyParts);
                //      QString newFile = dirs.takeLast();
                //      QString dirPath = "/"+dirs.join("/");
 
                //      _notifyExceptions.append(path);
                //      _notifyExceptions.append(dirPath);
                //      r->_notifyExceptions.append( this );
 
                        if (r)
                                VFS::LOG( QString("Creating on '%1'").arg(path), 8, _user );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "rm")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        bool s = i.value().toBool();
 
                        if (s)
                        {
                                VFS_request *r = createRequest(VFS_request::rm, path, _user);
 
                                //add _notifyExceptions entries for the new file and its containing folder.
                //FIXME: Disabled notifyException for rm... does it need to be enabled?
                //              QStringList dirs = path.split("/",Qt::SkipEmptyParts);
                //              QString newFile = dirs.takeLast();
                //              QString dirPath = "/"+dirs.join("/");
 
                //              _notifyExceptions.append(path);
                //              _notifyExceptions.append(dirPath);
                //              r->_notifyExceptions.append( this );
 
                                VFS::LOG( QString("Deleting '%1'").arg(path), 8, _user );
 
                                issueRequest(r);
                        }
                        else
                                VFS::ERROR( QString("Useless rm request on '%1'.  Value was false." ).arg(path), 5, _user );
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "subscribe")
        {
                QJsonObject::iterator i = attrs.begin();
 
                VFS_request::requestType reqtype = VFS_request::subscribe;
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        int c = i.value().toInt();
 
                        if (c)
                        {
                                VFS_request *r = createRequest(reqtype,path,_user);
 
                                r->_metadata["subscriptions"] = c;
                                VFS::LOG( QString("Subscribing +%1 to '%2'").arg(c).arg(path), 8, _user );
 
                                issueRequest(r);
                        }
                        else
                                VFS::ERROR( QString("Useless subscribe request on '%1': count was %2." ).arg(path).arg(c), 5, _user );
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "read")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        VFS_request::requestType reqtype = VFS_request::read;
 
                        QString path = rutils::cleanPath( i.key() );
 
                        if (i.value().isDouble())       //a normal request
                        {
                                int c = i.value().toInt();
 
                                if (c)
                                {
                                        VFS_request *r = createRequest(reqtype,path,_user);
 
                                        VFS::LOG( QString("Reading from '%1'").arg(path), 8, _user );
 
                                        issueRequest(r);
                                }
                                else
                                        VFS::ERROR( QString("Useless read request on '%1': count was %2." ).arg(path).arg(c), 5, _user );
                        }
                        else if (i.value().isObject())  //a request with metadata
                        {
                                QJsonObject m = i.value().toObject();
 
                                VFS_request *r = createRequest(reqtype,path,_user,QJsonDocument(),m);
 
                                VFS::LOG( QString("Reading with metadata from '%1'").arg(path), 8, _user );
 
                                issueRequest(r);
                        }
                        else
                                VFS::ERROR( QString("Malformed read request on '%1'." ).arg(path), 5, _user );
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "submit" || tag == "write")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        QJsonObject data = i.value().toObject();
 
                        VFS_request::requestType reqtype = tag == "submit" ? VFS_request::submit : VFS_request::write;
 
                        VFS_request *r = createRequest(reqtype, path, _user, QJsonDocument(data) );
 
                        //VFS::WARN( QString("DIFF: %1").arg(QString(d.toJson())) );
 
                        //add to notifyExceptions because we don't want the submit data to come back to the sender
                        r->_notifyExceptions.append( notifyException(this,path) );
                        //printf("EXCEPT ADD: %p %s\n",this,qUtf8Printable(path));
 
                        VFS::LOG( QString("%1 to '%2'").arg(tag[0].toUpper()+tag.mid(1)).arg(path), 8, _user );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "diff")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        QJsonObject data = i.value().toObject();
 
                        VFS_request *r = createRequest(VFS_request::diff, path, _user, QJsonDocument(data) );
 
                        r->_notifyExceptions.append( notifyException(this,path) );
 
                        VFS::LOG( QString("Diff on '%1'").arg(path), 8, _user );
 
                        //issueRequest(r);
                        applyDiff(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "unsubscribe")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        VFS_request::requestType reqtype = VFS_request::unsubscribe;
 
                        QString path = rutils::cleanPath( i.key() );
                        int c = i.value().toInt();
 
                        if (c)
                        {
                        //      VFS_remotoserver_request *r = new  VFS_remotoserver_request(reqtype,this,path,_user,false);
                                VFS_request *r = createRequest(reqtype,path,_user);
 
                                r->_metadata["unsubscriptions"] = c;
 
                                VFS::LOG( QString("Unsubscribing -%1 from '%2'").arg(c).arg(path), 8, _user );
 
                                issueRequest(r);
                        }
                        else
                                VFS::ERROR( QString("Useless unsubscribe request on '%1': count was %2." ).arg(path).arg(c), 5, _user );
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "ls")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString id = i.key();
                        QJsonObject o = i.value().toObject();
                        QString path = o["path"].toString();
                        QJsonObject m = o["metadata"].toObject();
                        //QJsonDocument d = QJsonDoument(o["data"]);    //should we include data here?
 
                //      VFS_remotoserver_request *r = new VFS_remotoserver_request(VFS_request::ls,this,path,_user,false);
                        VFS_request *r = createRequest(VFS_request::ls,path,_user,QJsonDocument(),m);
 
                        r->_metadata["id"] = id;
 
                        VFS::LOG( QString("Listing '%1'").arg(path), 8, _user );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "metadata")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        //int c = i.value().toInt();
 
                //      VFS_remotoserver_request *r = new  VFS_remotoserver_request(VFS_request::metadata,this,path,_user,false);
                        VFS_request *r = createRequest(VFS_request::metadata,path,_user);
 
                        VFS::LOG( QString("Metadata on '%1'").arg(path), 8, _user );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "requestlock")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while (i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        QJsonObject data = i.value().toObject();
 
                        VFS::LOG( QString("Request lock on '%1'").arg(path), 8, _user );
 
                        VFS_request *r = createRequest(VFS_request::requestlock, path, _user, QJsonDocument(data) );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "releaselock")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while ( i != attrs.end() )
                {
                        QString path = rutils::cleanPath( i.key() );
                        QJsonObject data = i.value().toObject();
 
                        VFS::LOG( QString("Release lock on '%1'").arg(path), 8, _user );
 
                        VFS_request *r = createRequest(VFS_request::releaselock, path, _user, QJsonDocument(data) );
 
                        issueRequest(r);
 
                        ++i;
                }
 
                return d;
        }
 
        if (tag == "code")
        {
                QJsonObject::iterator i = attrs.begin();
 
                while ( i != attrs.end() )
                {
                        QString library = i.key();
                        //we ignore i.value() for now, which should always be true
 
                        VFS_request *r = createRequest(VFS_request::code,library,_user);
                        VFS_request *c = VFS_creator::code(r);
 
                        if (c->hasCallback())   //it needs to be dispatched, probably because it is remote
                        {
                                //printf("ORIGIN: %s\n",qUtf8Printable(c->_origin->className()));
 
                                //this is almost certainly on a different thread
                                QMetaObject::invokeMethod(c->_origin,"executeRequest",Qt::AutoConnection,Q_ARG(VFS_request*, c));
                        }
                        else
                        {
                                if (c->_success)
                                {       QJsonObject o = c->_data.object();
                                        writeUICode(o["name"].toString(),o["code"].toString(),r->_reason);
                                }
                                else
                                {
                                        writeUICode(library,"",r->_reason);
                                }
 
                                delete c;
                        }
 
                        ++i;
                }
 
                return d;
        }
 
        /*
        if (tag == "codeDirectory")
        {
                QString error;
                QJsonObject o = VFS_creator::codeDirectory(error);
 
                VFS::LOG( QString("Requested code directory"), 9, _user );
 
                writeUICodeDirectory(o,error);
 
                return d;
        }
        */
 
        VFS::ERROR( QString("Received invalid %1 command: %2").arg(className()).arg(tag), 0, _user );
        VFS::ERROR( QString("%1").arg(data.data()), 0, _user );
 
        return d;
}
 
void VFS_remotoserver_client::authenticate(QJsonDocument d)
{
        QString command = d.object()["command"].toString();
 
        if ( command!="identify")
        {
                VFS::ERROR( "Not authenticated!", 0, className() );
                VFS::ERROR( QString("Received: %1").arg(qUtf8Printable(d.toJson())), 0, className() );
                //printf("Not authenticated!\nReceived:\n%s\n",qUtf8Printable(d.toJson()));
 
                QJsonObject r,a;
                r["command"] = "authorization";
                a["accepted"] = false;
                r["attributes"] = a;
                QJsonDocument rd(r);
                writeText(rd.toJson());
                close();
                return;
        }
        else
        {
                QJsonObject o = d.object()["attributes"].toObject();
                o["address"] = _address.toString();
                _server->authenticate(this, o);
        }
}
 
VFS_node *VFS_remotoserver_client::find(VFS_request *r)
{
        Q_UNUSED(r);
 
        return this;
}
 
QString VFS_remotoserver_client::reportDetails()
{
        QString s = QString("user: %1\ntype: %2").arg(_user).arg(_type);
 
        return s;
}
 
void VFS_remotoserver_client::write(VFS_request *r)
{
        //printf("VFS_remotoserver_client WRITE!\n");
        writeUIWrite(r->_path,r->_data,r->_metadata);
 
        //VFS_node::write(r);
        r->_success = true;
}
 
void VFS_remotoserver_client::rm(VFS_request *r)
{
        writeUIRM(r->_path);
 
        r->_success = true;
}
 
void VFS_remotoserver_client::receiveResponse(VFS_request *t)
{
        //printf("RECEIVED: %s\n",qUtf8Printable(t->toJson(0,true)));
 
        if (!_authenticated)
        {
                _authenticated = t->_success;
 
                if (_authenticated)
                {
                        QJsonObject o = t->_data.object();
                        _user = o["username"].toString();
                        _type = o["type"].toString();
                        _parameters = o["parameters"].toObject();
 
                        if (_user == "")
                                printf("AUTH:\n%s\n",qUtf8Printable(t->toJson(0,true)));
 
                        VFS::LOG( QString("'%1' authenticated by '%2' on %3").arg(_user).arg(t->_initialPath).arg(QDateTime::currentDateTime().toString(Qt::SystemLocaleLongDate)), 3 );
 
                        //if (!_parameters.isEmpty())
                        //      printf("PARAMETERS:\n%s\n",qUtf8Printable( QJsonDocument(_parameters).toJson() ));
 
                        _server->authorize( this, o );
                }
                else
                {
                        if (!t->_reason.isEmpty())
                                VFS::WARN( t->_reason );
 
                        //keep looping through the auth paths until sent is false.
                        bool sent = _server->authenticate(this, t->_data.object());
 
                        if (!sent)
                        {
                                QString m = "Authentication denied.";
                                QString user = t->_data.object()["username"].toString();
 
                                //if (!t->_reason.isEmpty())
                                //      m = t->_reason;
 
                                //if (!t->_user.isEmpty())
                                if (!user.isEmpty())
                                {       m = QString("Authentication denied for user '%1'").arg(user);
                                        VFS::ERROR( m );
                                }
 
                                QJsonObject r,a;
                                r["command"] = "authorization";
                                a["reason"] = m;
                                a["accepted"] = false;
                                r["attributes"] = a;
 
                                writeText(QJsonDocument(r).toJson());
                                close();
                        }
                }
 
                delete t;
                return;
        }
        else if (!_authorized)
        {
                _authorized = t->_success;
 
                if (_authorized)                                //authentication and authorization are successful now
                {
                        _session = t->_session;                 //store the session pointer
 
                        QJsonObject r;
                        r["command"] = "authorization";
                        r["attributes"] = t->_data.object();
 
                        writeText(QJsonDocument(r).toJson());
                        authorized();                           //the node has been authorized... call this for subclasses that need it.
                }
                else
                {
                        QString m = QString("Authorization denied for user '%1'").arg(t->_user);
                        VFS::ERROR( m );
 
                        if (!t->_reason.isEmpty())
                                m = t->_reason;
 
                        QJsonObject r,a;
                        r["command"] = "authorization";
                        a["reason"] = m;
                        a["accepted"] = false;
                        r["attributes"] = a;
 
                        writeText(QJsonDocument(r).toJson());
                        close();
                }
 
                delete t;
                return;
        }
 
        VFS_websocket_client::receiveResponse(t);
        //VFS_node::receiveResponse(t);
}
 
void VFS_remotoserver_client::addSourcePathMap(VFS_node *source, QString path)
{
        QMutexLocker l(&_lock);
 
        if (!source)
        {       VFS::ERROR("NO SOURCE, WON'T ADD!\n");
                return;
        }
 
        if (!_sourcePathMap.contains(source))
        {       _sourcePathMap.insert(source,path);
                connect(source, SIGNAL(unmounted(VFS_node*)), this, SLOT(removeSourcePathMap(VFS_node*)));
        }
        //else
        //      VFS::WARN( QString("Not duplicating path %1 in pathMap.  Attempted: %2, existing: %3").arg((quintptr)source).arg(path).arg(_sourcePathMap[source]) );
}
 
void VFS_remotoserver_client::removeSourcePathMap(VFS_node *s)
{
        QMutexLocker l(&_lock);
 
        if (s)
        {       if (_sourcePathMap.contains(s))
                {       //QString p = _sourcePathMap.value(s);
                        _sourcePathMap.remove(s);
                }
                //else
                //      VFS::WARN( QString("Could not remove non-existent entry %1 from sourcePathMap.").arg((quintptr)s) );
        }
        else
                VFS::WARN( QString("Could not remove null sender %1 from sourcePathMap.").arg((quintptr)sender()) );
}
 
bool VFS_remotoserver_client::writeUIDiff(QString path, QJsonDocument diff, QString user, bool binary)
{
        //printf("WRITE UI DIFF: %s\n",qUtf8Printable(path));
 
        //QMutexLocker l(&_lock);
 
        QJsonObject r;
        r["command"] = "diff";
        r["user"] = user;
 
        QJsonObject a;
        a["path"] = path;
 
        if (diff.isEmpty())
                a["diff"] = QJsonValue::Null;
        else
                a["diff"] = diff.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIRead(QString path, QJsonDocument data, QJsonObject metadata, bool binary)
{
        QJsonObject r;
        r["command"] = "read";
 
        QJsonObject a;
        a["path"] = path;
        a["type"] = metadata["type"].toString();
        a["metadata"] = metadata;
 
        if (data.isEmpty())
                a["data"] = QJsonValue::Null;
        else
                a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIWrite(QString path, QJsonDocument data, QJsonObject metadata, bool binary)
{
        QJsonObject r;
        r["command"] = "write";
 
        QJsonObject a;
        a["path"] = path;
        a["type"] = metadata["type"].toString();
        a["metadata"] = metadata;
 
        if (data.isEmpty())
                a["data"] = QJsonValue::Null;
        else
                a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIRM(QString path, bool binary)
{
        QJsonObject r;
        r["command"] = "rm";
 
        QJsonObject a;
        a["path"] = path;
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUISubscribe(QString path, QJsonDocument data, QJsonObject metadata, bool binary)
{
        //QMutexLocker l(&_lock);
 
        QJsonObject r;
        r["command"] = "subscribe";
 
        QJsonObject a;
        a["path"] = path;
        a["type"] = metadata["type"].toString();
        a["metadata"] = metadata;
 
        if (data.isEmpty())
                a["data"] = QJsonValue::Null;
        else
                a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUILS(QString id, QString path, QJsonDocument data, QJsonObject metadata, bool binary)
{
        QJsonObject r;
        r["command"] = "ls";
 
        QJsonObject a;
        a["id"] = id;
        a["path"] = path;
        a["metadata"] = metadata;
        a["data"] = data.object();
 
        r["attributes"] = a;
 
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIMetadata(QString path, QJsonObject metadata, bool binary)
{
        QJsonObject r;
        r["command"] = "metadata";
 
        QJsonObject a;
        a["path"] = path;
        //a["type"] = metadata["type"].toString();
        a["metadata"] = metadata;
        //a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIRequestLock(QString path, QJsonDocument data, bool binary)
{
        QJsonObject r;
        r["command"] = "requestlock";
 
        QJsonObject a;
        a["path"] = path;
        a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUIReleaseLock(QString path, QJsonDocument data, bool binary)
{
        QJsonObject r;
        r["command"] = "releaselock";
 
        QJsonObject a;
        a["path"] = path;
        a["data"] = data.object();
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUICode(QString name, QString code, QString error, bool binary)
{
        QJsonObject r;
        r["command"] = "code";
 
        QJsonObject a;
        a["name"] = name;
        a["code"] = code;
 
        if (!error.isEmpty())
        {       a["error"] = error;
                VFS::ERROR( error );
        }
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeUICodeDirectory(QJsonObject o, QString error, bool binary)
{
        QJsonObject r;
        r["command"] = "codeDirectory";
 
        QJsonObject a;
        a["directory"] = o;
 
        if (!error.isEmpty())
        {       a["error"] = error;
                VFS::ERROR( error );
        }
 
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeError(QString message, bool binary)
{
    //QMutexLocker l(&_lock);
 
        QJsonObject r,a;
        r["command"] = "error";
        a["message"] = message;
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeRequestError(QString command, QString path, QString reason, bool binary)
{
        QJsonObject r,a;
        r["command"] = "requesterror";
        a["command"] = command;
        a["path"] = path;
        a["reason"] = reason;
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
bool VFS_remotoserver_client::writeRequestSuccess(QString command, QString path, QJsonDocument data, QJsonObject metadata, bool binary)
{
        QJsonObject r,a;
        r["command"] = "requestsuccess";
        a["command"] = command;
        a["path"] = path;
        if (!data.isEmpty())
                a["data"] = data.object();
        if (!metadata.isEmpty())
                a["metadata"] = metadata;
        r["attributes"] = a;
        QJsonDocument rd(r);
 
        if (binary)
                return writeBinary(rd.toJson());
        else
                return writeText(rd.toJson());
}
 
QJsonObject VFS_remotoserver_client::parameters() const
{
        return _parameters;
}
 
VFS_remotoserver_request::VFS_remotoserver_request(VFS_request::requestType type, VFS_remotoserver_client *origin, QString path, QString user, QJsonDocument data, QJsonObject metadata, bool binary)
: VFS_request(type,origin,path,user,data,metadata)
, _binary(binary)
{
}
 
VFS_remotoserver_request::~VFS_remotoserver_request()
{
}
 
void VFS_remotoserver_request::execute()
{
        VFS_remotoserver_client *c = dynamic_cast<VFS_remotoserver_client *>(_origin);
 
        if (c && VFS_node::__isNode(c))
        {
                switch(_requestType)
                {
                        case VFS_request::read:                 if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::read was not successful on '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR( _reason );
 
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "read", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //and upon successful read, send the contents of the file back.
                                                                        _success = c->writeUIRead( _initialPath, _data, _metadata, _binary);
                                                                }
 
                                                                break;
 
                        case VFS_request::subscribe:            if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::subscribe was not successful on '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR( _reason );
 
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "subscribe", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //and upon subscription, send the contents of the file back.
                                                                        _success = c->writeUISubscribe( _initialPath, _data, _metadata, _binary );
 
                                                                        //add the (successfully subscribed) path to the paths map here for diffs on the client
                                                                        c->addSourcePathMap(_responder,_prefixPath.join('/'));
 
                                                                        //printf("XX INITIAL: %s\nXX PRFIXJN: %s\n",qUtf8Printable(_initialPath),qUtf8Printable(_prefixPath.join('\n')));
                                                                }
 
                                                                break;
 
                        case VFS_request::unsubscribe:          if (!_success)
                                                                {
                                                                        //VFS::ERROR( "remotoserver_request::unsubscribe was not successful." );
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "unsubscribe", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //do nothing here... the path no longer exists for the client
                                                                        //c->writeRequestSuccess( "unsubscribe", _initialPath );
                                                                }
 
                                                                break;
 
                        case VFS_request::write:                if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = "remotoserver_request::write was not successful.";
 
                                                                        VFS::ERROR( _reason );
 
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "write", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //FIXME: this should be uncommented, but will require
                                                                        //re-working the paneManager to be a subscribed thing
                                                                        //instead of a special case in vfsClient...
                                                                        //the paneManager should be a plain old object in the objectRegistry
                                                                        //c->writeRequestSuccess( "write", _initialPath );
                                                                }
 
                                                                break;
 
                        case VFS_request::submit:               if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = "remotoserver_request::submit was not successful.";
 
                                                                        VFS::ERROR( _reason );
 
                                                                        c->writeError(_reason);
                                                                        //c->writeRequestError( "submit", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //c->writeRequestSuccess( "submit", _initialPath );
                                                                }
 
                                                                break;
 
                        case VFS_request::create:               if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::create failed: '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR(_reason);
 
                                                                        c->writeError(_reason);
                                                                        //c->writeRequestError( "create", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        c->writeRequestSuccess( "create", _initialPath, _data, _metadata );
                                                                }
 
                                                                break;
 
                        case VFS_request::rm:                   if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::rm failed: '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR(_reason);
 
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "rm", _initialPath, _reason);
                                                                }
                                                                else
                                                                {
                                                                        c->writeRequestSuccess( "rm", _initialPath );
                                                                }
 
                                                                break;
 
                        case VFS_request::ls:                   if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::ls failed: '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR( _reason );
 
                                                                        c->writeError(_reason);
                                                                        //c->writeRequestError( "ls", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //printf("ls was successful.\n");
 
                                                                        //FIXME: arguably, closest container should be set here
                                                                        //if (_metadata.value("closest",false).toBool())
                                                                        //{     printf("LS WITH CLOSEST:\n%s\n",qUtf8Printable(_prefixPath.join('/') + "/" + _path));
                                                                        //      _metadata["closestContainer"] = ....
                                                                        //}
 
                                                                        _success = c->writeUILS(_metadata["id"].toString(),_initialPath,_data,_metadata);
                                                                }
 
                                                                break;
 
                        case VFS_request::metadata:             if (!_success)
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::metadata was not successful on '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR( _reason );
 
                                                                        //c->writeError(_reason);
                                                                        c->writeRequestError( "metadata", _initialPath, _reason );
                                                                }
                                                                else
                                                                {
                                                                        //and upon successful read, send the contents of the metadata back.
                                                                        _success = c->writeUIMetadata( _initialPath, _metadata);
                                                                }
 
                                                                break;
 
                        case VFS_request::diff:                 //printf("%s RECEIVED DIFF: %s\n",qUtf8Printable(_origin->className()),qUtf8Printable(toJson(0,true,true)));
 
                                                                //DO NOT WRITE UIDIFF HERE
                                                                //c->writeUIDiff( _initialPath, _data, _user, _binary );
 
                                                                //instead execute as normal
                                                                VFS_request::execute();
                                                                break;
 
                        case VFS_request::requestlock:          //if (!_success)
                                                                //{
                                                                //}
                                                                c->writeUIRequestLock( _initialPath, _data );
                                                                break;
 
                        case VFS_request::releaselock:          //if (!_success)
                                                                //{
                                                                //}
                                                                c->writeUIReleaseLock( _initialPath, _data );
                                                                break;
 
                        case VFS_request::code:                 if (_success)
                                                                {
                                                                        //printf("RECEIVED CODE RESPONSE\n");
                                                                        QJsonObject o = _data.object();
                                                                        QString name = o["name"].toString();
                                                                        QString code = o["code"].toString();
                                                                        QString error = _reason;
 
                                                                        //upon successful code request, send the code back.
                                                                        _success = c->writeUICode(name,code,error);
                                                                }
                                                                else
                                                                {
                                                                        if (_reason.isEmpty())
                                                                                _reason = QString("remotoserver_request::code was not successful on '%1'.").arg(_initialPath);
 
                                                                        VFS::ERROR( _reason );
 
                                                                        //c->writeError(_reason);
                                                                        c->writeUICode(_path,"",_reason);
                                                                }
 
                                                                break;
 
                        default:                                VFS::ERROR( QString("unknown request type on remotoserver_request: %1").arg(_requestType), 0, _user );
                                                                break;
                }
        }
        else
        {
                VFS::ERROR("COULD NOT CAST TO REMOTOSERVER_CLIENT... was it deleted?\n");
                //throw "Could not dynamic cast to remotoserver_client.";
                _success = false;
        }
 
        //provide error logging if unsuccessful
        //VFS_request::execute();
}