VFS_curl.cpp

Go to the documentation of this file.

 
#include <QNetworkRequest>
 
#include "VFS.h"
#include "VFS_base/VFS_icons.h"
 
#include "VFS_curl.h"
 
VFS_curl::VFS_curl(QString url, bool json, bool poll, int expire, int timeout)
: VFS_node()
, _url(url)
, _json(json)
, _poll(poll)
, _expire(expire)
, _manager(this)
, _stale(true)
, _valid(false)
, _getting(false)
, _timeout(timeout)
, _request(nullptr)
{
        connect(        &_manager,      SIGNAL(finished(QNetworkReply*)),
                        this,           SLOT(replyFinished(QNetworkReply*))     );
 
        //connect(      &_manager,      SIGNAL(QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error)),
        //              this,           SLOT(replyError(&MyClass::slotError);
 
        connect(        &_manager,      SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
                        this,           SLOT(sslErrors(QNetworkReply*,QList<QSslError>))        );
 
        _timer.setSingleShot(true);
        connect(        &_timer,        SIGNAL(timeout()),
                        this,           SLOT(networkTimeout())  );
 
        if (_poll)
        {
                //this will create a log entry with the VFS_curl user, which may not be right if subclassed.
                //this->expire();
 
                //done this way instead so we don't get a log entry from VFS_curl when this is subclassed.
                QTimer::singleShot( 0, this, SLOT(expire()) );
        }
}
 
VFS_curl::~VFS_curl()
{
}
 
QByteArray VFS_curl::icon()
{
        return VFS_icons::get("stream");
}
 
QString VFS_curl::reportDetails()
{
        return _url.toString( QUrl::FullyEncoded );
}
 
bool VFS_curl::isContainer()
{
        return false;
}
 
void VFS_curl::metadata(VFS_request *r)
{
        VFS_node::metadata(r);
 
        r->_metadata["type"] = _json ? "json" : "httpdata";
 
        if (_stale)
        {
                r->_isCallback = true;
                get(r);
        }
        else
        {
                if (_valid)
                {
                        r->_metadata["http"] = _metadata;
                        r->_success = true;
                }
                else
                {
                        r->_reason = _reason;
                        r->_success = false;
                }
        }
}
 
void VFS_curl::read(VFS_request *r)
{
        if (_stale)
        {
                r->_isCallback = true;
                get(r);
        }
        else
        {
                if (_valid)
                {
                        r->_data.setObject(_data);
                        r->_success = true;
                }
                else
                {
                        r->_reason = _reason;
                        r->_success = false;
                }
        }
}
 
void VFS_curl::get(VFS_request *r)
{
        if (_getting)
        {       _requests << r;
                return;
        }
 
        VFS::LOG("Requesting "+_url.toString(QUrl::FullyEncoded),9,className());
 
        //VFS_request *s = r->getCallback(this);        //don't do this
        r->_isCallback = true;                          //defer the response as if there were a callback.
 
        QNetworkRequest request(_url);
        request.setAttribute(QNetworkRequest::FollowRedirectsAttribute,true);
        //request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
 
        //QNetworkReply *p = _manager.post(request,params.query().toUtf8());
        //QNetworkReply *p = _manager.get( request );
        _request = _manager.get( request );
 
        //connect(      _request,       SIGNAL(QNetworkReply::error(QNetworkReply::NetworkError code)   ),
        //              this,           SLOT(networkReplyError(QNetworkReply::NetworkError code)        );
 
        _timer.start(_timeout);
 
        _requests << r;
 
        _getting = true;
}
 
void VFS_curl::replyFinished(QNetworkReply *reply)
{
        VFS::LOG("Request completed: "+_url.toString(QUrl::FullyEncoded),9,className());
 
        _getting = false;
        _stale = false;
        QTimer::singleShot( _expire, this, SLOT(expire()) );
 
        _timer.stop();          //will restart after expire
 
        QByteArray data;
 
        if (reply->error())
        {
                VFS::ERROR( _reason = reply->errorString(), 0, className() );
                _valid = false;
                _metadata = QJsonObject();
                data = "";
        }
        else
        {       _reason = "";
                _valid = true;
                _metadata = getHeaders(reply);
                data = reply->readAll();
        }
 
        QJsonObject jsondata = _json ? QJsonDocument::fromJson(data).object() : QJsonObject { {"data",QString(data)} };
        QJsonObject jsondiff;
        _data = parse(jsondata,jsondiff);
 
        while (!_requests.isEmpty())
        {
                VFS_request *r = _requests.takeFirst();
                r->_success = _valid;
 
                if (!_valid)
                {
                        r->_reason = QString("Curl error: %1").arg(_reason);
                }
                else
                {
                        switch (r->_requestType)
                        {
                                case VFS_request::read:         r->_data.setObject( _data );
                                                                break;
 
                                case VFS_request::metadata:     r->_metadata["http"] = _metadata;
                                                                break;
 
                                case VFS_request::subscribe:    r->_metadata["http"] = _metadata;
                                                                r->_data.setObject( _data );
                                                                break;
 
                                case VFS_request::diff:         //the case where the current data has been expired and polled
                                                                if (!jsondiff.isEmpty())
                                                                {
                                                                        r->_data.setObject(jsondiff);
 
                                                                        //VFS::WARN("emit diff here!");
                                                                        //printf("%s\n",qUtf8Printable(r->toJson(0,true)));
 
                                                                        emit diff(this,r);
                                                                }
 
                                                                delete r;
                                                                continue;
                                                                //break;
 
                                default:                        break;
                        }
                }
 
                issueResponse(r);
        }
 
        reply->deleteLater();
}
 
void VFS_curl::networkTimeout()
{
        VFS::WARN("Request timeout: "+_url.toString(QUrl::FullyEncoded),0,className());
 
        if (_request)
                _request->abort();
 
        _request = nullptr;
}
 
void VFS_curl::expire()
{
        _stale = true;
 
        if (_poll)
        {
                VFS_request *r = createRequest(VFS_request::diff,"",className(),QJsonDocument());
                //r->_isCallback = true;
                get(r);
        }
 
}
 
QJsonObject VFS_curl::getHeaders(QNetworkReply *reply)
{
        /*
        static QMap<QNetworkRequest::KnownHeaders, QString> headers = {
                { QNetworkRequest::ContentDispositionHeader,    "ContentDispositionHeader"      },
                { QNetworkRequest::ContentTypeHeader,           "ContentTypeHeader"             },
                { QNetworkRequest::ContentLengthHeader,         "ContentLengthHeader"           },
                { QNetworkRequest::LocationHeader,              "LocationHeader"                },
                { QNetworkRequest::LastModifiedHeader,          "LastModifiedHeader"            },
                { QNetworkRequest::CookieHeader,                "CookieHeader"                  },
                { QNetworkRequest::SetCookieHeader,             "SetCookieHeader"               },
                { QNetworkRequest::UserAgentHeader,             "UserAgentHeader"               },
                { QNetworkRequest::ServerHeader,                "ServerHeader"                  }
        };
 
        QJsonObject m;
 
        QMap<QNetworkRequest::KnownHeaders,QString>::iterator h = headers.begin();
        while (h != headers.end())
        {
                QVariant v = reply->header(h.key());
                if(v.isValid())
                        m[h.value()] = v.to
 
                h++;
        }*/
 
        QJsonObject m;
 
        QList<QByteArray> headers = reply->rawHeaderList();
        foreach (QByteArray h,headers)
                m[QString(h)] = QString(reply->rawHeader(h));
 
        return m;
}
 
 
void VFS_curl::sslErrors(QNetworkReply *reply,const QList<QSslError> &errors)
{
        //Q_UNUSED(reply)
 
        for (int i=0;i<errors.size();i++)
                VFS::ERROR( errors.at(i).errorString(), 0, className() );
 
        replyFinished(reply);
}
 
QJsonObject VFS_curl::parse(QJsonObject data, QJsonObject &diffout)
{
        //VFS_request *r = createRequest(VFS_request::diff,"",className(),QJsonDocument(data));
        //emit diff(this,r);
 
        diffout = data;
 
        return data;
}