VFS_tcp_export_client.cpp

Go to the documentation of this file.

 
#include "VFS.h"
#include "VFS_creator.h"
#include "utilities/rutils.h"
 
#include "VFS_tcp_export_client.h"
#include "VFS_tcp_export_sessionManager.h"
 
#include "VFS_base/VFS_acl.h"
#include "VFS_tcp_mount.h"
 
VFS_tcp_export_client::VFS_tcp_export_client(QTcpSocket *socket, QString exportRoot, bool ssl, QSslConfiguration sslConfiguration, QByteArray icon)
: VFS_tcp_client(socket,ssl,sslConfiguration)
, _exportRoot(exportRoot)
, _icon(icon)
{
        connect( this, SIGNAL(readyMessage(QByteArray)), this, SLOT(receiveMessage(QByteArray)) );
 
        connect( VFS::root(), SIGNAL(codeDirectoryUpdated()), this, SLOT(sendCodeDirectory()) );
 
        //send codeDirectory to new connection
        connect( this, SIGNAL(connected()), this, SLOT(sendCodeDirectory()) );
        //sendCodeDirectory();
}
 
VFS_tcp_export_client::~VFS_tcp_export_client()
{
        QMap<QString, QList<VFS_tcp_export_request *> >::iterator it = _queuedRequests.begin();
        while (it != _queuedRequests.end())
        {
                QList<VFS_tcp_export_request *> l = it.value();
                while (l.length())
                {
                        VFS_request *r = l.takeFirst();
                        delete r;
                }
 
                it++;
        }
}
 
void VFS_tcp_export_client::receiveMessage(QByteArray message)
{
        #ifdef COMPRESS_TCP_MOUNT
        message = qUncompress(message);
        if (message.length() == 0)
                VFS::ERROR("(1) Uncompressed message size was 0.");
        #endif
 
        #ifdef SHOW_JSON
        printf("%s received: %s\n",qUtf8Printable(className()),qUtf8Printable(message));
        #endif
 
        VFS_tcp_export_request *r = VFS_tcp_export_request::fromMessage(message,_exportRoot,this);
 
        if (r)
        {
                if (!r->_pendingSession)
                        executeMessageRequest(r);
        }
        else
                VFS::ERROR( QString("Can't satisfy %1 request without sender or valid json message.").arg(className()) );
}
 
void VFS_tcp_export_client::executeMessageRequest(VFS_tcp_export_request *r)
{
        if (r->_id == POST_ID_PING)
        {
                VFS::LOG( QString("%1 :: ping").arg(className()), 9 );
                delete r;
                return;
        }
 
        if (r->_id == POST_ID_SESSION_DATA)
        {
                //printf("received session data: %s\n",qUtf8Printable(r->toJson(0,true,true)));
 
                //register the session
                QString id = r->_metadata["sessionid"].toString();
 
                if (r->_data.isNull())
                        printf("Received invalid session information.  FIXME: remove the request and abort.");
 
                QJsonObject data = r->_data.object();
                VFS_session *s = new VFS_session(this,nullptr,data);
                VFS_tcp_export_sessionManager::registerSession(id,s);
 
                //set _session on each item in the queue
                QList< VFS_tcp_export_request *> queue = _queuedRequests.take(id);
                for( int i=0; i<queue.count(); ++i )
                        queue[i]->_session = s;
 
                //execute the queue
                for( int i=0; i<queue.count(); ++i )
                        executeMessageRequest( queue[i] );
 
                delete r;
                return;
        }
 
        //check to see if access is allowed on the _exportRoot
        if (r->_session)
        {
                //printf("checking access on %s\n",qUtf8Printable(_exportRoot));
 
                if (!VFS_acl::checkAllowAccess(r->_session,_exportRoot))
                {
                        VFS::ERROR( r->_reason = QString("ACL access was denied for user '%1' on '%2' (%3)").arg(r->_user).arg(_exportRoot).arg(r->_initialPath) );
                        r->_success = false;
                        receiveResponse(r);
                        return;
                }
                //else
                //      printf("access granted to %s on %s\n",qUtf8Printable(r->_session->fetchSessionValue("user").toString()),qUtf8Printable(_exportRoot));
        }
 
        switch(r->_requestType)
        {
                case VFS_request::codeDirectory:        {
                                                                VFS::ERROR( QString("Requested code directory"), 9, r->_user );
 
                                                                QString error;
                                                                QJsonObject o = VFS_creator::codeDirectory(error);
                                                                r->_data.setObject(o);
                                                                r->_success = true;
 
                                                                receiveResponse(r);
                                                        }
 
                                                        break;
 
                case VFS_request::code:                 {
                                                                VFS_request *c = VFS_creator::code(r);
 
                                                                if (c->hasCallback())   //it needs to be dispatched
                                                                {
                                                                        //issueRequest(c);
 
                                                                        //this is almost certainly on a different thread
                                                                        QMetaObject::invokeMethod(c->_origin,"executeRequest",Qt::AutoConnection,Q_ARG(VFS_request*, c));
                                                                }
                                                                else
                                                                {
                                                                        //issueResponse(c);
                                                                        //c->execute();
                                                                        receiveResponse(c);
                                                                }
                                                        }
 
                                                        break;
 
                case VFS_request::unsubscribe:          {
                                                                VFS::LOG( QString("'%1' request on '%2' (%3)").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path).arg(r->_metadata["unsubscriptions"].toInt(0)), 9, r->_user );
 
                                                                if (r->_path.startsWith( _exportRoot+"/__ACL__/"))
                                                                {
                                                                        QString p = r->_path.mid( QString(_exportRoot+"/__ACL__/").length() );
                                                                        //r->_path = r->_initialPath = p;
                                                                        r->_path = p;
                                                                        issueRequest(r);
                                                                }
                                                                else
                                                                        issueRequest(r);
                                                        }
 
                                                        break;
 
 
                case VFS_request::subscribe:            {
                                                                VFS::LOG( QString("'%1' request on '%2' (%3)").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path).arg(r->_metadata["subscriptions"].toInt(0)), 9, r->_user );
 
                                                                //printf("subscribe: %s %s\n",qUtf8Printable(r->_path),qUtf8Printable(_exportRoot+"/__ACL__"));
 
                                                                if (r->_path.startsWith( _exportRoot+"/__ACL__/"))
                                                                {
                                                                        QString p = r->_path.mid( QString(_exportRoot+"/__ACL__/").length() );
                                                                        //r->_path = r->_initialPath = p;
                                                                        r->_path = p;
                                                                        //printf("new path: %s\n",qUtf8Printable(p));
                                                                        issueRequest(r);
                                                                }
                                                                else
                                                                        issueRequest(r);
                                                        }
 
                                                        break;
 
                case VFS_request::submit:               {
                                                                //VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
 
                                                                if (r->_path.startsWith( _exportRoot+"/__ACL__/"))
                                                                {
                                                                        QString p = r->_path.mid( QString(_exportRoot+"/__ACL__/").length() );
                                                                        r->_path = r->_initialPath = p;
                                                                        VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
                                                                        issueRequest(r);
                                                                }
                                                                else
                                                                {
                                                                        VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
                                                                        issueRequest(r);
                                                                }
                                                        }
 
                                                        break;
 
                case VFS_request::metadata:             {
                                                                VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
 
                                                                if (r->_path.startsWith( _exportRoot+"/__ACL__/"))
                                                                {
                                                                        QString p = r->_path.mid( QString(_exportRoot+"/__ACL__/").length() );
                                                                        r->_path = r->_initialPath = p;
                                                                        issueRequest(r);
                                                                }
                                                                else
                                                                        issueRequest(r);
                                                        }
 
                                                        break;
 
                case VFS_request::read:                 {
                                                                VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
 
                                                                if (r->_path.endsWith("__ACL__"))
                                                                {
                                                                        QStringList l = VFS_acl::fetchACLPaths();
                                                                        QJsonObject o;
                                                                        for (int i=0;i<l.length();i++)
                                                                        {
                                                                                o[ l[i] ] = false;
                                                                        }
 
                                                                        /*
                                                                        QMutexLocker m(&VFS_tcp_mount::_mountsLock);
                                                                        QList<VFS_tcp_mount *> mounts = VFS_tcp_mount::_mounts;
 
                                                                        for (int i=0;i<mounts.length();i++)
                                                                        {
                                                                                if (mounts[i]->isMounted())
                                                                                {
                                                                                        o[ mounts[i]->path()+"/__ACL__" ] = true;
                                                                                }
                                                                        }
                                                                        */
 
                                                                        r->_data.setObject(o);
                                                                        r->_success = true;
 
                                                                        receiveResponse(r);
                                                                }
                                                                else
                                                                        issueRequest(r);
                                                        }
 
                                                        break;
 
                default:                                {
                                                                VFS::LOG( QString("'%1' request on '%2'").arg(VFS_request::requestTypeStrings[r->_requestType]).arg(r->_path), 9, r->_user );
                                                                issueRequest(r);
                                                        }
                                                        break;
        }
}
 
void VFS_tcp_export_client::applyDiff(VFS_request *t)
{
        //printf("CLIENT APPLY DIFF!\n");
 
        VFS_tcp_client::applyDiff(t);
 
        VFS_node *source = t->_origin;
 
        if (_sourcePathMap.contains(source))
        {
                //update t->_path to reflect the path on the other side of the mount
                t->_path = rutils::cleanPath( _sourcePathMap.value(source)+"/"+t->_path );
        }
        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->_originPath), 0, t->_user );
                printf("BAD DIFF: %s\n",qUtf8Printable(t->toJson(0,true,true)));
                t->_success = false;
                return;
        }
 
        QByteArray diff = t->toJson(POST_ID_DIFF);
 
        #ifdef SHOW_JSON
        printf("%s sends: %s\n",qUtf8Printable(className()),qUtf8Printable(diff));
        #endif
 
        #ifdef COMPRESS_TCP_MOUNT
        diff = qCompress(diff);
        #endif
 
        writeMessage(diff);
}
 
 
void VFS_tcp_export_client::receiveResponse(VFS_request *t)
{
        //VFS_node::receiveResponse(t);
 
        //if (t->_success)
        switch(t->_requestType)
        {
                case VFS_request::subscribe:    {
                                                        VFS_node *s = t->_responder;
                                                        if (s && t->_success)
                                                        {
                                                                //addSourcePathMap(s,t->_prefixPath.join('/'));
                                                                //printf("PREFIX PATH: %s\n",qUtf8Printable(t->_prefixPath.join('/')));
 
                                                                if ( t->_initialPath.startsWith("__ACL__") )
                                                                {       addSourcePathMap(s,rutils::cleanPath( t->_initialPath ));
                                                                        //printf("ACL subscribe: %s\n",qUtf8Printable(t->_initialPath));
                                                                }
                                                                else
                                                                {
                                                                        QString pp = t->_prefixPath.join('/');
                                                                        pp = pp.mid(_exportRoot.length()+1);
                                                                        addSourcePathMap(s,rutils::cleanPath( pp ));
                                                                }
 
                                                                //this export may have an icon override
                                                                if (t->_path == "" && _icon != "")
                                                                {
                                                                        if (t->_metadata.contains("icon"))
                                                                        {
                                                                                t->_metadata["icon"] = QString(_icon);
                                                                        }
                                                                }
                                                        }
                                                        else
                                                        {       //VFS::ERROR( QString("%1 no subscribe responder, or _success=false.  Not adding to sourcePathMap.").arg(className()) );
                                                                //if (!s)
                                                                //      VFS::ERROR( QString("%1 no subscribe responder.  Not adding to sourcePathMap.").arg(className()) );
                                                        }
                                                }
                                                break;
 
                case VFS_request::unsubscribe:  {
                                                        VFS_node *s = t->_responder;
                                                        if (s && t->_success)
                                                        {
                                                                //VFS::ERROR("removing subscription path");
 
                                                                //FIXME: there may be multiple subscriptions from the mount to this path... don't delete the entry unless the node is deleted.
 
                                                                /*
                                                                int c = -1;
                                                                if (    _subscribers.contains(t->_initialPath)                          &&
                                                                        _subscribers[t->_initialPath].contains(t->_originPath)          &&
                                                                        _subscribers[t->_initialPath][t->_originPath].contains(s)       )
                                                                        c = _subscribers[t->_initialPath][t->_originPath].value(s,-2);
 
                                                                printf("unsubscribe count: %d\n",c);
 
                                                                if (c==-1)
                                                                {
                                                                        printf("KEYS: '%s'\n",qUtf8Printable(_subscribers.keys().join("'\n'")));
                                                                        foreach(QString k,_subscribers.keys())
                                                                        {
                                                                                printf("  KEYS2: '%s' '%s'\n",qUtf8Printable(k),qUtf8Printable(_subscribers[k].keys().join("'\n'")));
                                                                        }
                                                                        printf("originPath: %s\n",qUtf8Printable(t->_originPath));
                                                                        printf("REQ: %s\n",qUtf8Printable(t->toJson(0,true,true)));
                                                                }
                                                                */
 
                                                                //FIXME: for now, we just leave the entry
                                                                //removeSourcePathMap(s);
                                                        }
                                                        //else
                                                        //      VFS::ERROR( QString("%1 no unsubscribe responder, or _success=false").arg(className()) );
                                                }
                                                break;
 
                case VFS_request::write:
                case VFS_request::submit:       {
                                                        //if (!t->_success)     //no need to send the data back
                                                        {
                                                                t->_data = QJsonDocument();
                                                        }
                                                        //else
                                                        //      but we don't kill it here so the requestor receives acknowledgement and can clean up the initial VFS_request
                                                }
                                                break;
 
                default:                        break;
        }
 
//      VFS_tcp_export_request *rq = dynamic_cast<VFS_tcp_export_request *>(t);
//      if (!rq)
//      {
//              VFS::ERROR("need a copy constructor thing like VFS_remotoserver_client::receiveResponse!");
//      }
 
        VFS_tcp_client::receiveResponse(t);
}
 
void VFS_tcp_export_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
        {
                if (_sourcePathMap[source] != path)
                if (!path.startsWith("__ACL__"))
                        VFS::WARN( QString("Not duplicating path %1 in pathMap.  Attempted: '%2', existing: '%3'").arg((quintptr)source).arg(path).arg(_sourcePathMap[source]) );
        }
}
 
 
void VFS_tcp_export_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()) );
}
 
 
void VFS_tcp_export_client::sendCodeDirectory()
{
        VFS::LOG("Sending code directory.",9,className());
 
        QString error;
        QJsonObject o = VFS_creator::codeDirectory(error);
        //VFS_request *r = createRequest(VFS_request::codeDirectory,"",className(),QJsonDocument(o));
        VFS_tcp_export_request *r = new VFS_tcp_export_request(this,"");
        r->_requestType = VFS_request::codeDirectory;
        r->_user = className();
        r->_id = POST_ID_CODE_DIRECTORY;
        r->_data.setObject(o);
        r->_success = true;
        r->execute();
        delete r;
}
 
VFS_tcp_export_request::VFS_tcp_export_request(VFS_tcp_client *origin, QString exportRoot)
: VFS_request(VFS_request::none,origin)
, _id(POST_ID_NONE)
, _exportRoot(exportRoot)
, _pendingSession(false)
{
}
 
VFS_tcp_export_request::~VFS_tcp_export_request()
{
}
 
void VFS_tcp_export_request::fromJsonObject(QJsonObject json, bool includeInitialPath)
{
        VFS_request::fromJsonObject(json,includeInitialPath);
 
        // We only replace the _id if it has not been set yet.
        // if it has been set, it is part of a chained request,
        // like if a mount is being re-exported
        if (_id == POST_ID_NONE)
                _id = static_cast<postID>(json["id"].toInt());
 
        if (_requestType != VFS_request::code)
                _path = rutils::cleanPath( _exportRoot+"/"+_path );
 
        if (json.contains("session"))
        {
                //printf("SESSION: %s\n",qUtf8Printable(json["session"].toString()));
 
                //get the session, or request it from the server if it doesn't exist
                QString session = json["session"].toString();
                VFS_session *s = VFS_tcp_export_sessionManager::fetchSession(session);
 
                if (!s)
                {
                        VFS_tcp_export_client *c = dynamic_cast<VFS_tcp_export_client *>(_origin);
 
                        if (c)
                        {       _pendingSession = true;
                                c->_queuedRequests[session] << this;
                                VFS_tcp_export_sessionManager::requestSession(session,c);
                        }
                        else
                                VFS::WARN("Can't queue request on non-VFS_tcp_export_client!");
                }
                else
                        this->_session = s;
        }
}
 
VFS_tcp_export_request *VFS_tcp_export_request::fromMessage(QByteArray message, QString exportRoot, VFS_tcp_client *origin)
{
        QJsonDocument d = QJsonDocument::fromJson( message );
 
        if (!d.isNull())
        {
                VFS_tcp_export_request *r = new VFS_tcp_export_request(origin,exportRoot);
                r->fromJsonObject( d.object(), true );
                return r;
        }
 
        return nullptr;
}
 
QByteArray VFS_tcp_export_request::toJson(postID id, bool ignoreSuccess, bool includeInitialPath)
{
        QJsonDocument d;
        QJsonObject o;
 
        //_id = id;
 
        o["id"] = id;
        o["type"] = _requestType;
        //o["originPath"] = _originPath;
        //o["path"] = rutils::cleanPath( _path.mid(_exportRoot.length()) );     //don't want this!  It's already removed by find()
        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;
 
        o["success"] = _success;
 
        //o["session"] = ??
 
        //if this request is a diff, it's likely that the diff originated from a submit request
        //record the id of the request so _notifyExceptions can be updated on the receiving side
        if (id == POST_ID_DIFF)
                o["sourceID"] = _id;
 
        d.setObject(o);
        return d.toJson();
}
 
VFS_request *VFS_tcp_export_request::createDiff(VFS_node *origin, QString originPath)
{
        //VFS_request *r = new VFS_tcp_export_request(VFS_request::diff,origin,_path,_user,_data,_metadata);
        VFS_tcp_client *c = dynamic_cast<VFS_tcp_client *>(_origin);
        VFS_tcp_export_request *r = new VFS_tcp_export_request(c,_exportRoot);
        r->_requestType = VFS_request::diff;
        r->_origin = origin;
        r->_path = _path;
        r->_initialPath = _path;
        r->_user = _user;
        r->_data = _data;
        r->_metadata = _metadata;
 
        r->_id = _id;
 
        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;
}
 
void VFS_tcp_export_request::execute()
{
        VFS_tcp_client *c = dynamic_cast<VFS_tcp_client *>(_origin);
 
        if (c)
        {
                if (!_success)
                {       if (_reason == "" && _requestType!=VFS_request::unsubscribe)
                                VFS::WARN( QString("VFS_tcp_export_request id %1 (%3) on '%2' has failed without providing a reason... reporting error to mount.").arg(_id).arg(_initialPath).arg(VFS_request::requestTypeStrings[_requestType]), 0, _user );
                        //VFS::WARN( _reason, 0, _user );
                }
 
                QByteArray response = toJson(_id);
 
                #ifdef SHOW_JSON
                printf("VFS_tcp_export_request sends: %s\n",qUtf8Printable(response));
                #endif
 
                #ifdef COMPRESS_TCP_MOUNT
                response = qCompress(response);
                #endif
 
                c->writeMessage(response);
        }
        else
        //      VFS::WARN( QString("VFS_tcp_export_request could not cast to client... failing.") );
                VFS_request::execute();
}