|
|
#include <Network/Downloader.h>
|
|
|
#include <memory>
|
|
|
|
|
|
#include <QNetworkRequest>
|
|
|
#include <QNetworkReply>
|
|
|
#include <QNetworkAccessManager>
|
|
|
#include <QAuthenticator>
|
|
|
#include <QVariant>
|
|
|
#include <QHash>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QReadWriteLock>
|
|
|
#include <QMutex>
|
|
|
#include <QThread>
|
|
|
#include <QObject>
|
|
|
#include <QtConcurrent/QtConcurrent>
|
|
|
|
|
|
class Downloader::p_Downloader : public QObject
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
using login_pair=QPair<QString,QString>;
|
|
|
QNetworkAccessManager manager;
|
|
|
QMutex manager_lock;
|
|
|
QReadWriteLock auth_lock;
|
|
|
QHash<QString,login_pair> auth;
|
|
|
QReadWriteLock pending_requests_lock;
|
|
|
QHash<QUuid,QNetworkReply*> pending_requests;
|
|
|
|
|
|
QNetworkRequest buildRequest(const QString& url, const QString &user="", const QString &passwd="")
|
|
|
{
|
|
|
QNetworkRequest request;
|
|
|
request.setUrl(QUrl(url));
|
|
|
request.setRawHeader("User-Agent", "SciQLop 1.0");
|
|
|
if(user!="" and passwd!="")
|
|
|
{
|
|
|
//might grow quickly since we can have tons of URLs for the same host
|
|
|
auth[url]=login_pair(user,passwd);
|
|
|
QString login = "Basic "+user+":"+passwd;
|
|
|
request.setRawHeader("Authorization",login.toLocal8Bit());
|
|
|
}
|
|
|
return request;
|
|
|
}
|
|
|
signals:
|
|
|
void _get_sig(const QNetworkRequest& request,std::function<void (QNetworkReply* reply)> callback);
|
|
|
private slots:
|
|
|
void _get(const QNetworkRequest& request,std::function<void (QNetworkReply* reply)> callback)
|
|
|
{
|
|
|
QNetworkReply *reply = manager.get(request);
|
|
|
QObject::connect(reply, &QNetworkReply::finished, [reply=reply,callback=callback](){callback(reply);});
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
explicit p_Downloader()
|
|
|
{
|
|
|
auto login_bambda = [this](QNetworkReply * reply, QAuthenticator * authenticator)
|
|
|
{
|
|
|
QWriteLocker loc{&auth_lock};
|
|
|
if(auth.contains(reply->url().toString()))
|
|
|
{
|
|
|
auto login = auth[reply->url().toString()];
|
|
|
authenticator->setUser(login.first);
|
|
|
authenticator->setPassword(login.second);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
QObject::connect(&manager, &QNetworkAccessManager::authenticationRequired, login_bambda);
|
|
|
QObject::connect(this, &p_Downloader::_get_sig, this, &p_Downloader::_get, Qt::QueuedConnection);
|
|
|
}
|
|
|
|
|
|
Response get(const QString& url, const QString &user="", const QString &passwd="")
|
|
|
{
|
|
|
QNetworkAccessManager manager;
|
|
|
auto login_bambda = [user=user,passwd=passwd](QNetworkReply * reply, QAuthenticator * authenticator)
|
|
|
{
|
|
|
authenticator->setUser(user);
|
|
|
authenticator->setPassword(passwd);
|
|
|
};
|
|
|
QObject::connect(&manager, &QNetworkAccessManager::authenticationRequired, login_bambda);
|
|
|
Response resp;
|
|
|
QNetworkRequest request = buildRequest(url, user, passwd);
|
|
|
auto reply = manager.get(request);
|
|
|
while (reply->isRunning())
|
|
|
{
|
|
|
QCoreApplication::processEvents();
|
|
|
QThread::usleep(1000);
|
|
|
}
|
|
|
QVariant status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
|
|
|
resp = Response(reply->readAll(), status_code.toInt());
|
|
|
return resp;
|
|
|
}
|
|
|
|
|
|
QUuid getAsync(const QString &url, std::function<void (QUuid ,Response)> callback, const QString &user, const QString &passwd)
|
|
|
{
|
|
|
auto uuid = QUuid::createUuid();
|
|
|
QNetworkRequest request = buildRequest(url, user, passwd);
|
|
|
manager_lock.lock();
|
|
|
QNetworkReply *reply = manager.get(request);
|
|
|
manager_lock.unlock();
|
|
|
auto callback_wrapper = [url, uuid, callback, this](){
|
|
|
QNetworkReply* reply;
|
|
|
{
|
|
|
QWriteLocker locker(&pending_requests_lock);
|
|
|
reply = pending_requests.take(uuid);
|
|
|
}
|
|
|
QVariant status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
|
|
|
Response resp = Response(reply->readAll(), status_code.toInt());
|
|
|
{
|
|
|
QWriteLocker loc{&auth_lock};
|
|
|
auth.remove(url);
|
|
|
}
|
|
|
delete reply;
|
|
|
callback(uuid, resp);
|
|
|
};
|
|
|
QObject::connect(reply, &QNetworkReply::finished, callback_wrapper);
|
|
|
{
|
|
|
QWriteLocker locker(&pending_requests_lock);
|
|
|
pending_requests[uuid] = reply;
|
|
|
}
|
|
|
return uuid;
|
|
|
}
|
|
|
bool downloadFinished(QUuid uuid)
|
|
|
{
|
|
|
QReadLocker locker(&pending_requests_lock);
|
|
|
if(pending_requests.contains(uuid))
|
|
|
{
|
|
|
auto req = pending_requests[uuid];
|
|
|
return req->isFinished();
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
Response Downloader::get(const QString &url, const QString &user, const QString &passwd)
|
|
|
{
|
|
|
return Downloader::instance().impl->get(url, user, passwd);
|
|
|
}
|
|
|
|
|
|
QUuid Downloader::getAsync(const QString &url, std::function<void (QUuid ,Response)> callback, const QString &user, const QString &passwd)
|
|
|
{
|
|
|
return Downloader::instance().impl->getAsync(url, callback, user, passwd);
|
|
|
}
|
|
|
|
|
|
bool Downloader::downloadFinished(QUuid uuid)
|
|
|
{
|
|
|
return Downloader::instance().impl->downloadFinished(uuid);
|
|
|
}
|
|
|
|
|
|
Downloader::Downloader()
|
|
|
:impl(spimpl::make_unique_impl<p_Downloader>())
|
|
|
{
|
|
|
}
|
|
|
|
|
|
#include "Downloader.moc"
|
|
|
|
