VFS_thread.cpp

Go to the documentation of this file.

 
#include "VFS_thread.h"
 
#include <QCoreApplication>
 
#include "VFS.h"
#include "VFS_creator.h"
 
int VFS_thread::_threadcount = 0;
 
VFS_thread::VFS_thread(QDomElement nodeConfig, QVariantMap env, bool printConfig)
: VFS_node()
, _thread(this, nodeConfig, env, printConfig)
, _node(nullptr)
{
        QMutexLocker l(&VFS_node::__allNodesMutex);                             //to make the threadcount reliable
 
        _threadcount++;
        VFS_creator::_outstanding.acquire();                                    //acquire a resource for synchronization
 
        VFS::LOG( QString(" -Creating thread #%1 '%2:%3'").arg(_threadcount).arg(nodeConfig.tagName()).arg(nodeConfig.attribute("name")), 9 );
 
        //name the thread for gdb or ps or lldb
        _thread.setObjectName( nodeConfig.tagName()+":"+nodeConfig.attribute("name") );
 
        connect( &_thread,      SIGNAL(nodeCreated(VFS_node*)), this,           SLOT(setNode(VFS_node*)) );     //listen for the node creation
        connect( this,          SIGNAL(mounted()),              &_thread,       SLOT(start()) );                //start the thread once we're mounted
        connect( this,          SIGNAL(unmounted(VFS_node *)),  &_thread,       SLOT(quit()) );                 //kill the thread on unmount
        connect( &_thread,      SIGNAL(finished()),             this,           SLOT(defunct())) ;              //unmount the thread once the thread is complete
}
 
VFS_thread *VFS_thread::fromConfig(QString configString, QVariantMap env, bool printConfig)
{
        QString error;
        QDomDocument config;
 
        if (config.setContent( configString, &error ))
        {
                QDomElement child = config.firstChildElement();
                return new VFS_thread(child,env,printConfig);
        }
        else
                VFS::ERROR( QString("Could not create thread with config: %1\nerror: %2\n").arg(configString).arg(error));
 
        return nullptr;
}
 
 
VFS_thread::~VFS_thread()
{
        /*
        if (_node)
        {       delete _node;
                //_node->deleteLater();         //because this object has no parent, we want to trigger deletion of this branch when the thread finishes
        }
        */
 
        VFS::LOG( QString(" -Destroying thread %1").arg(_thread.objectName()), 9 );
 
        _thread.quit();
        _thread.wait();
 
        _threadcount--;
}
 
 
void VFS_thread::defunct()
{
        emit finished(true);                    //to include deletion
}
 
 
int VFS_thread::threadcount()
{
        return _threadcount+1;
}
 
 
void VFS_thread::setNode(VFS_node *node)
{
        if (_node)
        {       VFS::ERROR("Node already set on thread.  Aborting this command.");
                return;
        }
 
        _node = node;
 
        disconnect( &_thread,   SIGNAL(nodeCreated(VFS_node*)), this,           SLOT(setNode(VFS_node*)) );                     //listen for the node creation
        //connect( this,        SIGNAL(unmounted(VFS_node *)),  _node,          SIGNAL(unmounted(VFS_node *)) );        //trigger unmount when this node is unmounted
        connect( &_thread,      SIGNAL(finished()),             _node,          SLOT(deleteLater()) );
        connect( _node,         SIGNAL(finished(bool)),         this,           SIGNAL(finished(bool)) );
 
        //printf("releasing...\n");
        //VFS_creator::outstanding.release();                                   //release what was acquired in the constructor
}
 
 
VFS_node *VFS_thread::append(QString name, VFS_node *node, bool containerCheck, QString user)
{
        Q_UNUSED(name);
        Q_UNUSED(node);
        Q_UNUSED(containerCheck);
        Q_UNUSED(user);
 
        VFS::ERROR( "Adding children to a VFS_thread is unsupported... pass a config instead" );
 
        //return _node->append(name,node);
 
        return nullptr;
}
 
 
VFS_node *VFS_thread::mount()
{
        if (_node)
                _node->mount();                 //FIXME: is this thread-safe?
 
        return VFS_node::mount();
}
 
 
VFS_node *VFS_thread::unmount()
{
        if (_node)
                _node->unmount();               //FIXME: is this thread-safe?
 
        return VFS_node::unmount();
}
 
 
bool VFS_thread::isContainer()
{
        QMutexLocker l(&_lock);
 
        if (!_node) return false;
 
        return _node->isContainer();            //FIXME: it's bad to directly call anything from a dfferent thread... this will need to be deprecated at some point!
}
 
 
bool VFS_thread::hasNode()
{
        return (_node != nullptr);
}
 
 
/*
void VFS_thread::metadata(VFS_request *r)
{
        //QMutexLocker l(&_lock);
 
        //FIXME: is it threadsafe to allow metadata to break the thread boundary?
        //seems needed for VFS_applications
        //_node->metadata(r);
 
        VFS_request *p = r->getCallback(this);
        issueRequest(_node,p);
 
        //issueRequest(_node,r);
 
        //in this case, we actually don't want to call the base class because the default behavior would do stuff that may override the callback
        //VFS_node::metadata(r);
}
*/
 
 
VFS_node *VFS_thread::find(VFS_request *r)
{
        Q_UNUSED(r);
 
        return this;
}
 
 
void VFS_thread::subtreeRequest(VFS_request *t)
{
        //Q_UNUSED(t);
 
        //if this happens, something is routing the wrong way?
        //or is it?
        //VFS::ERROR("THREAD SUBTREE REQUEST");
 
        executeRequest(t);
        //issueRequest(_node,t);
}
 
 
void VFS_thread::executeRequest(VFS_request *t)
{
        if (_node)
                issueRequest(_node,t);
        else
                VFS::ERROR( QString("No node set for this thread: %1\n%2\n").arg((quintptr)thread()).arg(QString(t->toJson(0,true))), 0, t->_user );
}
 
 
VFS_threadthread::VFS_threadthread(VFS_node *p, QDomElement nodeConfig, QVariantMap env, bool printConfig)
: QThread(p)
, _nodeConfig(nodeConfig)
, _env(env)
, _printConfig(printConfig)
, _node(nullptr)
{
}
 
VFS_threadthread::~VFS_threadthread()
{
        //covered as a connection above
        /*
        if (_node)
        {       //delete _node;
                _node->deleteLater();           //because this object has no parent, we want to trigger deletion of this branch when the thread finishes
        }
        */
}
 
 
void VFS_threadthread::run()
{
        //VFS::LOG( QString("Creating node(s) for '%1' (%2)").arg(_nodeConfig.attribute("name")).arg(_nodeConfig.tagName()) );
 
        _nodeConfig.removeAttribute("thread");  //so we're not in a loop
 
        try
        {
                _node = VFS_creator::constructNode(_nodeConfig,_env,_printConfig);
        }
        catch(...)
        {
                QString currentConfigFile = _env["file"].toString();
                QString tag = _nodeConfig.tagName();
                //printf("%s\n", qUtf8Printable( QString("Failed to load config '%1' on tag '%2'.").arg(currentConfigFile).arg(tag) ) );
                VFS::ERROR( QString("Failed to load config '%1' on tag '%2'.").arg(currentConfigFile).arg(tag), 0, "VFS_threadthread" );
                VFS_creator::_outstanding.release();                            //release what was acquired in the constructor
                emit creationFailed();
                return;
        }
 
        if(!_node)
        {       VFS::ERROR( QString("Thread %1 unable to create '%2'").arg(objectName()).arg(_nodeConfig.tagName()) );
                VFS_creator::_outstanding.release();                            //release what was acquired in the constructor
                emit creationFailed();
                return;
        }
 
        _node->mount();                                                         //call mount() on the thread node now that the thread is started
 
        emit nodeCreated(_node);                                                //report the node back to the VFS_thread
 
        VFS_creator::_outstanding.release();                                    //release what was acquired in the constructor
 
        VFS_creator::_outstanding.acquire(VFS_CREATOR_MAX_OUTSTANDING);         //wait to claim all available
        VFS_creator::_outstanding.release(VFS_CREATOR_MAX_OUTSTANDING);         //release them all (now we're in sync)
 
        //printf("THREAD EXEC\n");
 
        exec();
 
        //printf("THREAD COMPLETE\n");
}