VFS_session.cpp

Go to the documentation of this file.

 
#include <QFileInfo>
#include <QRegularExpression>
 
#include "VFS_session.h"
 
#include "VFS.h"
#include "VFS_base/VFS_icons.h"
#include "utilities/rutils.h"
 
QJsonObject VFS_session::_sessionTypes = QJsonObject();
QJsonObject VFS_session::_sessionDefaults = QJsonObject();
QMutex VFS_session::_sessionTypesLock(QMutex::Recursive);
bool VFS_session::_initializedTypes = false;
 
VFS_session::VFS_session(VFS_node *client, VFS_sessionManager *manager, QString user, QString type, QString home, QString authpath, QDateTime expires, QString address, QJsonObject parameters, QString authtoken)
: VFS_node()
, _initialized(false)
, _client(client)
, _manager(manager)
, _created(QDateTime::currentDateTimeUtc())
, _expires(expires)
, _address(address)
, _user(user)
, _type(type)
, _home(home)
, _authpath(authpath)
, _authtoken(authtoken)
, _tokens(parameters)
{
        _tokens["username"] = _user;
        _tokens["authpath"] = _authpath;
        _tokens["type"] = _type;
        _tokens["home"] = _home;
        _tokens["address"] = _address;
 
        if (_expires.isValid())
                VFS::LOG( QString("Created '%1' session for user '%2' which will expire on %3").arg(_type).arg(_user).arg(_expires.toLocalTime().toString(Qt::SystemLocaleLongDate)), 6 );
        else
                VFS::LOG( QString("Created non-expiring '%1' session for user '%2'").arg(_type).arg(_user), 6 );
 
        //start the session timer at one minute
        if (_expires.isValid())
                timerID = startTimer( 60000, Qt::VeryCoarseTimer );
 
        if (__isNode(_client))
        {
                //ensure that the session and the client die at the same time
                //the connection must be a Qt::QueuedConnection for cases of single-threaded configuration
                connect( this, SIGNAL(finished(bool)), _client, SIGNAL(finished(bool)), Qt::QueuedConnection );
                connect( _client, SIGNAL(finished(bool)), this, SIGNAL(finished(bool)), Qt::QueuedConnection );
        }
        else
                VFS::WARN("Null or non-node client provided to session.");
}
 
VFS_session::VFS_session(VFS_node *client, VFS_sessionManager *manager, QJsonObject data)
: VFS_node()
, _initialized(false)
, _client(client)
, _manager(manager)
{
        _created = QDateTime::fromSecsSinceEpoch( (qint64) data["created"].toDouble() );
        //_expires = QDateTime::fromSecsSinceEpoch( (qint64) data["expires"].toDouble() );
        _expires = QDateTime::fromSecsSinceEpoch( (qint64) QDateTime::currentSecsSinceEpoch() + 590 );          //expire 10 minutes from now
        _address = data["address"].toString();
        _user = data["user"].toString();
        _type = data["type"].toString();
        _groups = data["groups"].toArray();
        _home = data["home"].toString();
        _authpath = "";
 
        _tokens = data["tokens"].toObject();
        _sessionData = data["sessionData"].toObject();
 
        if (_expires.isValid())
                VFS::LOG( QString("Created '%1' session for user '%2' which will expire on %3").arg(_type).arg(_user).arg(_expires.toLocalTime().toString(Qt::SystemLocaleLongDate)), 8 );
        else
                VFS::LOG( QString("Created non-expiring '%1' session for user '%2'").arg(_type).arg(_user), 8 );
 
        //start the session timer at one minute
        if (_expires.isValid())
                timerID = startTimer( 60000, Qt::VeryCoarseTimer );
 
        if (__isNode(_client))
        {
                //ensure that the session and the client die at the same time
                //the connection must be a Qt::QueuedConnection for cases of single-threaded configuration
                //connect( this, SIGNAL(finished(bool)), _client, SIGNAL(finished(bool)), Qt::QueuedConnection );
                connect( _client, SIGNAL(finished(bool)), this, SIGNAL(finished(bool)), Qt::QueuedConnection );
        }
        else
                VFS::WARN("Null or non-node client provided to session.");
}
 
VFS_session::~VFS_session()
{
        VFS::LOG( QString("Deleting %1 session for user '%2'").arg(_type).arg(_user), 7 );
}
 
 
void VFS_session::initializeTypes()
{
        QMutexLocker l(&_sessionTypesLock);
 
        if (_initializedTypes) return;
 
        QJsonObject t;
        t["preferencesPath"]    = "";
        t["interfacePath"]      = "";
 
        _sessionTypes["default"] = t;
 
        QJsonObject d;
        d["preferencesPath"]    = rutils::jsonResource( ":/skeleton/preferencesSkeleton.rfm" );
        d["interfacePath"]      = rutils::jsonResource( ":/skeleton/layout.rui" );
 
        _sessionDefaults["default"] = d;
 
        _initializedTypes = true;
}
 
 
bool VFS_session::registerSessionType(QString type, QJsonObject definition, QJsonObject defaults)
{
        QMutexLocker ll(&_sessionTypesLock);
 
        initializeTypes();
 
        if (!_sessionTypes.contains(type))
        {       _sessionTypes[type] = definition;
                _sessionDefaults[type] = defaults;
                VFS::LOG( QString("Registered VFS_session type '%1'.").arg(type), 8 );
                return true;
        }
        else
                VFS::WARN( QString("Can't register VFS_session type '%1'.  It is already registered.").arg(type) );
 
        return false;
}
 
 
QJsonValue VFS_session::fetchSessionValue(QString key)
{
        QMutexLocker l(&_lock);
 
        if (_sessionData.contains(key))
                return _sessionData.value(key);
 
        if (_tokens.contains(key))
                return _tokens.value(key);
 
        if (key == "user")
                return _user;
 
        if (key == "uidnumber")
                return _uidnumber;
 
        if (key == "type")
                return _type;
 
        if (key == "realname")
                return _realname;
 
        if (key == "groups")
                return _groups;
 
        return QJsonValue::Null;
}
 
 
QJsonValue VFS_session::fetchDefaultSessionValue(QString type, QString key)
{
        QMutexLocker ll(&_sessionTypesLock);
 
        if (_sessionDefaults.contains(type))
        if (_sessionDefaults[type].toObject().contains(key))
        {
                return _sessionDefaults[type].toObject()[key];
        }
 
        return QJsonValue::Null;
}
 
 
VFS_session *VFS_session::fetchSession(QString address)
{
        //for instance 0x00007fbfea385f90
 
        bool ok;
        VFS_node *n = (VFS_node *) address.toULongLong(&ok,0);
 
        if (ok)
        {
                if (__isNode(n))
                {
                        VFS_session *s = dynamic_cast<VFS_session *>(n);
 
                        if (s) return s;
                }
        }
 
        return nullptr;
}
 
 
QJsonObject VFS_session::toJson()
{
        QMutexLocker l(&_lock);
 
        QJsonObject o;
 
        o["created"] = _created.toSecsSinceEpoch();
        o["expires"] = _expires.toSecsSinceEpoch();
        o["address"] = _address;
 
        o["user"] = _user;
        o["uidnumber"] = _uidnumber;
        o["realname"] = _realname;
        o["groups"] = _groups;
        o["type"] = _type;
        o["home"] = _home;
        //o["authpath"] = _authpath;    //don't want this, it's meaningless to another VFS
 
        o["tokens"] = _tokens;
        o["sessionData"] = _sessionData;
 
        return o;
}
 
 
qint64 VFS_session::secondsToExpire()
{
        QDateTime n = QDateTime::currentDateTimeUtc();
        qint64 s = n.secsTo(_expires);
 
        return s;
}
 
 
QString VFS_session::authtoken()
{
        if (_authtoken.isEmpty())
                return "";
 
        return _authtoken.split("/",Qt::SkipEmptyParts).last();
}
 
 
bool VFS_session::isMemberOf(QString group)
{
        QMutexLocker l(&_lock);
 
        if (group == "")
                return false;
 
        if (_groups.contains(group))
                return true;
 
        return false;
}
 
 
bool VFS_session::isMemberOf(QStringList groups)
{
        QMutexLocker l(&_lock);
 
        foreach(QString g, groups)
        {       if (isMemberOf(g))
                        return true;
        }
 
        return false;
}
 
 
bool VFS_session::isContainer()
{
        return false;
}
 
 
QString VFS_session::reportDetails()
{
        QMutexLocker l(&_lock);
 
        QString e;
        if (_expires.isValid())
                e = _expires.toString(Qt::SystemLocaleLongDate);
        else
                e = "never";
 
        QString s = QString("user: %1\ntype: %2\naddress: %6\nexpires: %5\nhome: %3\nauth: %4\ngroups: %7").arg(_user).arg(_type).arg(_home).arg(_authpath).arg(e).arg(_address).arg(QString(QJsonDocument(_groups).toJson()).replace("\n",""));
 
        return s;
}
 
 
void VFS_session::timerEvent(QTimerEvent *event)
{
        if (event->timerId() == timerID)
        {
                if ( QDateTime::currentDateTimeUtc() >= _expires)
                {       VFS::WARN( QString("%1 session for user '%2' has expired.").arg(_type).arg(_user), 7 );
                        emit finished(true);
                }
        }
}
 
 
void VFS_session::initializeUser(VFS_request *r)
{
        if (_initialized)
        {
                VFS::ERROR(r->_reason = "Session is already initialized.",0,r->_user);
                r->_success = false;
                return;
        }
 
        //printf("INITIALIZE USER!\n");
 
        QMutexLocker ll(&_sessionTypesLock);
        QMutexLocker l(&_lock);
 
        QJsonObject o,t,d;
        QJsonObject::iterator i;
 
        //QString rel = "data/"+_user;
 
        //get the type-dependent data for this session
                if (_sessionTypes.contains(_type))
                        t = _sessionTypes[_type].toObject();
                else
                        t = _sessionTypes["default"].toObject();
 
                if (_sessionDefaults.contains(_type))
                        d = _sessionDefaults[_type].toObject();
                else
                        d = _sessionDefaults["default"].toObject();
 
        //resolve and store the resolved type-dependent data for this session
                _sessionData = resolveTokens(t);
 
        //if a token path is present we need to create or update the session token entry
                if (!_authtoken.isEmpty())
                {
                        QJsonObject tm;
                        tm["createIfMissing"] = true;
 
                        QJsonObject td;
                        td["username"] = _user;
                        td["authpath"] = _authpath;
                        td["expire"] = _expires.toSecsSinceEpoch()/60;
 
                        VFS_request *ta = createRequest(VFS_request::submit,_authtoken,"server",QJsonDocument(td),tm);
                        ta->_metadata["suppressError"] = true;
                        _initializers.enqueue(ta);
 
                        VFS_request *tb = createRequest(VFS_request::read,_authpath+"/"+_user,"server");
                        _initializers.enqueue(tb);
                }
 
        //check if the home directory and sub-paths and preferences exist, or create them
                //set up metadata
                        QJsonObject m;
                        m["createIfMissing"] = true;
                        m["container"] = true;
 
                //check paths
                        //check directories
                        m["container"] = true;  //just as a reminder
                        i = _sessionData.begin();
                        while (i != _sessionData.end())
                        {
                                QString s = i.value().toString();
 
                                //QFileInfo f(s);
                                //if (f.completeSuffix().isEmpty())     //if it's a directory
                                if (s.endsWith("/"))                    //if it's a directory
                                {
                                        //printf("dir: %s\n",qUtf8Printable(s));
 
                                        VFS_request *q = createRequest(VFS_request::read,s,_user,QJsonDocument(),m);
                                        _initializers.enqueue(q);
                                }
 
                                ++i;
                        }
 
                        //check files
                        m["container"] = false; //these are files
                        i = _sessionData.begin();
                        while (i != _sessionData.end())
                        {
                                QString s = i.value().toString();
 
                                //QFileInfo f(s);
                                //if (!f.completeSuffix().isEmpty())    //if it's a file
                                if (!s.endsWith("/"))
                                {
                                        //printf("file: %s\n",qUtf8Printable(s));
 
                                        VFS_request *q = createRequest(VFS_request::subscribe,s,_user,QJsonDocument(),m);
 
                                        if (d.contains(i.key()))
                                        {       q->_data.setObject( d[i.key()].toObject() );
                                                //printf("VAL: %s\n",qUtf8Printable( QJsonDocument( d[i.key()].toObject() ).toJson() ) );
                                        }
                                        else
                                        {       VFS::WARN( QString("No key '%2' in sessionDefaults for '%1' when creating '%3'").arg(_type).arg(i.key()).arg(s) );
                                        }
 
                                        _initializers.enqueue(q);
                                }
 
                                ++i;
                        }
 
        //kick off the first domino!
                r->_isCallback = true;
                _initializers.enqueue(r);
                dequeueInitializer();
}
 
 
void VFS_session::dequeueInitializer()
{
        if (_initializers.length())
        {
                VFS_request *r = _initializers.dequeue();
 
                //the last item is the sessionManager's initial request
                if (!_initializers.length())
                {
                        QJsonObject d = r->_data.object();
                        _uidnumber = (quint16) d["uidnumber"].toInt( 0 );
                        _realname = d["realname"].toString( _user );
                        _groups = d["groups"].toArray();
 
                        _tokens["realname"] = _realname;
                        _tokens["uidnumber"] = _uidnumber;
 
                        QJsonObject o = _sessionData;
 
                        //populate the additional data
                        o["accepted"] = true;
                        o["username"] = _user;
                        o["uidnumber"] = _uidnumber;
                        o["realname"] = _realname;
                        o["preferencesBase"] = _manager->getCWD();      //the base class for the preferences skeleton
 
                        r->_data.setObject(o);
 
                        r->_session = this;
                        r->_success = true;
 
                        _initialized = true;
 
                        issueResponse(r);
                }
                else
                        issueRequest(r);
        }
}
 
 
QJsonObject VFS_session::resolveTokens(QJsonObject data)
{
        QMutexLocker l(&_lock);
 
        QRegularExpression tokenRX("@([^@]+)@");
        QRegularExpressionMatch match;
 
        QJsonObject::iterator i;
        i = data.begin();
        while (i != data.end())
        {
                QString key = i.key();
                QString value = i.value().toString();
 
                match = tokenRX.match(value);
                while (match.hasMatch())
                {
                        QString matched = match.captured(1);
                        //printf("found: %s on %s\n",qUtf8Printable(matched),qUtf8Printable(key));
                        QString t = _tokens.contains(matched) ? _tokens[matched].toString() : "[unresolved: "+matched+"]";
                        value = value.replace("@"+matched+"@", t );
                        match = tokenRX.match(value);
                }
 
                //printf("value: %s\n",qUtf8Printable(value));
                data[key] = value;
 
                ++i;
        }
 
        //printf("%s\n", qUtf8Printable(QJsonDocument(data).toJson()));
 
        return data;
}
 
 
QByteArray VFS_session::icon()
{
        return VFS_icons::get("user");
}
 
 
void VFS_session::read(VFS_request *r)
{
        QJsonObject o;
        o["username"] = _user;
        o["uidnumber"] = _uidnumber;
        o["realname"] = _realname;
        o["groups"] = _groups;
        o["created"] = _created.toMSecsSinceEpoch();
        o["expires"] = _expires.toMSecsSinceEpoch();
        o["authpath"] = _authpath;
        o["type"] = _type;
        o["home"] = _home;
        o["address"] = _address;
 
        if (r->_session == this)
                o["self"] = true;
 
        r->_data.setObject(o);
        r->_success = true;
}
 
void VFS_session::rm(VFS_request *r)
{
        //FIXME: detect if termination was caused by admin request
        if (_client)
        {
                QJsonObject metadata;
                metadata["type"] = "reload";
 
                VFS_request *s = createRequest(VFS_request::write, "", r->_user, QJsonDocument(), metadata );
                issueRequest(_client,s);
        }
 
        //simplifies the teardown process and prevents spurious requests from not being satisfied
        //it should be here, and not in the destructor, to catch the effect as early as possible
        __removeNode(_client);
 
        VFS_node::rm(r);
}
 
void VFS_session::applyDiff(VFS_request *r)
{
        //printf("Apply diff!\n%s\n",qUtf8Printable(r->toJson(0,true,true)));
 
        if (r->_data.isEmpty())
                emit finished(true);
 
        r->_success = true;
}
 
void VFS_session::receiveResponse(VFS_request *r)
{
        //printf("VFS_session receiveResponse: %d %d %s %s\n",_initializers.length(),r->_requestType,qUtf8Printable(r->_initialPath),qUtf8Printable(r->_path));
        //printf("VFS_session receiveResponse: %s\n",qUtf8Printable(r->toJson(0,true,true)));
 
        if (r->_success)
        {
                //if it was a read from the auth node
                if (r->_initialPath == _authpath+"/"+_user)
                {
                        //printf("VFS_session user reload receiveResponse: %s\n",qUtf8Printable(r->toJson(0,true,true)));
 
                        if (_initializers.length())
                        {
                                QJsonObject l = _initializers.last()->_data.object();
                                QJsonObject d = r->_data.object();
                                l["username"] = d["username"];
                                l["uidnumber"] = d["uidnumber"];
                                l["realname"] = d["realname"];
                                l["groups"] = d["groups"];
 
                                _initializers.last()->_data.setObject(l);
                        }
                        else
                                VFS::WARN("Could not populate user information.");
                }
 
                dequeueInitializer();
        }
        else
        {
                //delete the initializers and die on failure to initialize
 
                while (_initializers.length() > 1)
                        delete _initializers.dequeue();
 
                if (_initializers.length())
                {
                        VFS_request *rr = _initializers.dequeue();
                        rr->_success = false;
                        rr->_reason = "Failed to initialize session. (failed at "+r->_initialPath+")";
                        issueResponse(rr);
                }
 
                emit finished();
 
                return;
        }
 
        VFS_node::receiveResponse(r);
}