void TransferApi::on(ConnectionManagerListener::Failed, const ConnectionQueueItem* aCqi, const string& aReason) noexcept {
auto t = getTransfer(aCqi->getToken());
if (!t) {
return;
}
onFailed(t, aCqi->getUser().user->isSet(User::OLD_CLIENT) ? STRING(SOURCE_TOO_OLD) : aReason);
}
void TransferApi::on(DownloadManagerListener::Failed, const Download* aDownload, const string& aReason) noexcept {
auto t = getTransfer(aDownload->getToken());
if (!t) {
return;
}
auto status = aReason;
if (aDownload->isSet(Download::FLAG_SLOWUSER)) {
status += ": " + STRING(SLOW_USER);
} else if (aDownload->getOverlapped() && !aDownload->isSet(Download::FLAG_OVERLAP)) {
status += ": " + STRING(OVERLAPPED_SLOW_SEGMENT);
}
onFailed(t, status);
}
void WebLoadManager::sendRequest(webFileLoaderPrivate *loader, const QString &redirect) {
Replies::iterator j = _replies.find(loader->reply());
if (j != _replies.cend()) {
QNetworkReply *r = j.key();
_replies.erase(j);
r->abort();
r->deleteLater();
}
QNetworkReply *r = loader->request(_manager, redirect);
connect(r, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(onProgress(qint64, qint64)));
connect(r, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onFailed(QNetworkReply::NetworkError)));
connect(r, SIGNAL(metaDataChanged()), this, SLOT(onMeta()));
_replies.insert(r, loader);
}
void QtTestApp::initUpdater()
{
createUpdaterWindow();
FvUpdater::sharedUpdater()->SetFeedURL("https://raw.github.com/ershovdz/WebMounter_Builds/master/Appcast.xml");
// signals from WINDOW
connect(m_updaterWindow, SIGNAL(installRequested()), FvUpdater::sharedUpdater(), SLOT(InstallUpdate()));
connect(m_updaterWindow, SIGNAL(skipInstallRequested()), FvUpdater::sharedUpdater(), SLOT(SkipUpdate()));
connect(m_updaterWindow, SIGNAL(remindLaterRequested()), FvUpdater::sharedUpdater(), SLOT(RemindMeLater()));
connect(m_updaterWindow, SIGNAL(cancelRequested()), FvUpdater::sharedUpdater(), SLOT(CancelUpdate()));
// signals from UPDATER
connect(FvUpdater::sharedUpdater(), SIGNAL(finished()), m_updaterWindow, SLOT(onFinished()));
connect(FvUpdater::sharedUpdater(), SIGNAL(failed(QString)), m_updaterWindow, SLOT(onFailed(QString)));
connect(FvUpdater::sharedUpdater(), SIGNAL(progress(uint)), m_updaterWindow, SLOT(onProgress(uint)));
connect(FvUpdater::sharedUpdater(), SIGNAL(updateAvailable(FvAvailableUpdate*)), this, SLOT(onUpdates(FvAvailableUpdate*)));
connect(FvUpdater::sharedUpdater(), SIGNAL(noUpdates()), this, SLOT(onNoUpdates()));
connect(FvUpdater::sharedUpdater(), SIGNAL(closeAppToRunInstaller()), this, SLOT(onCloseApp()));
}
UpdateStateRow::UpdateStateRow(QWidget *parent) : RpWidget(parent)
, _check(this, lang(lng_settings_check_now))
, _restart(this, lang(lng_settings_update_now)) {
connect(_check, SIGNAL(clicked()), this, SLOT(onCheck()));
connect(_restart, SIGNAL(clicked()), this, SIGNAL(restart()));
_versionText = lng_settings_current_version_label(lt_version, currentVersionText());
Core::UpdateChecker checker;
checker.checking() | rpl::start_with_next([=] {
onChecking();
}, lifetime());
checker.isLatest() | rpl::start_with_next([=] {
onLatest();
}, lifetime());
checker.progress(
) | rpl::start_with_next([=](Core::UpdateChecker::Progress progress) {
onDownloading(progress.already, progress.size);
}, lifetime());
checker.failed() | rpl::start_with_next([=] {
onFailed();
}, lifetime());
checker.ready() | rpl::start_with_next([=] {
onReady();
}, lifetime());
switch (checker.state()) {
case Core::UpdateChecker::State::Download:
setState(State::Download, true);
setDownloadProgress(checker.already(), checker.size());
break;
case Core::UpdateChecker::State::Ready:
setState(State::Ready, true);
break;
default:
setState(State::None, true);
break;
}
}
UpdateStateRow::UpdateStateRow(QWidget *parent) : TWidget(parent)
, _check(this, lang(lng_settings_check_now))
, _restart(this, lang(lng_settings_update_now)) {
connect(_check, SIGNAL(clicked()), this, SLOT(onCheck()));
connect(_restart, SIGNAL(clicked()), this, SIGNAL(restart()));
Sandbox::connect(SIGNAL(updateChecking()), this, SLOT(onChecking()));
Sandbox::connect(SIGNAL(updateLatest()), this, SLOT(onLatest()));
Sandbox::connect(SIGNAL(updateProgress(qint64, qint64)), this, SLOT(onDownloading(qint64, qint64)));
Sandbox::connect(SIGNAL(updateFailed()), this, SLOT(onFailed()));
Sandbox::connect(SIGNAL(updateReady()), this, SLOT(onReady()));
_versionText = lng_settings_current_version_label(lt_version, currentVersionText());
switch (Sandbox::updatingState()) {
case Application::UpdatingDownload:
setState(State::Download, true);
setDownloadProgress(Sandbox::updatingReady(), Sandbox::updatingSize());
break;
case Application::UpdatingReady: setState(State::Ready, true); break;
default: setState(State::None, true); break;
}
}
// IDispatch implementation
void CoAuthServiceCall::ReadyStateChange()
{
const DWORD dwRef = ExternalAddRef(); // lock protect your instance
try
{
switch (m_spRequest->readyState) {
case READYSTATE_LOADING:
{
TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_LOADING\n", (BSTR)m_bstrUrl, m_eState);
/*
* siehe auch: kommentar zu
* CoAuthServiceCall::m_bstrAccessToken UND
* IWorkflow::AuthorizeRequest
*/
oAuthLib::IAuthorizePtr spAuthorize;
if (SUCCEEDED(GetTokenServer(&spAuthorize)))
spAuthorize->AuthorizeRequest(m_spRequest, &m_bstrAccessToken);
}
break;
case READYSTATE_COMPLETE:
{
TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_COMPLETE\n", (BSTR)m_bstrUrl, m_eState);
/*
* das wird erst noetig wenn wir den UseCase: Shutdown, Wait for pending requests implementieren
* CComPtr < IWorkflow > spWorkflow;
* pThis->GetWorkflow(&spWorkflow);
* spWorkflow->FinalizeRequest(m_spRequest);
*/
if (200 == m_spRequest->status)
{
m_eState = Finish;
#ifdef AUTHORIZATION_SERVER_SUPPORT_JSON
/*
* das ist natuerlich LUXUS pur bzw. schon zuviel spezialisierung. es gibt ja auch noch XML
* https://casablanca.codeplex.com/wikipage?title=JSON&referringTitle=Documentation
*
* CAUTION: this is necessary to avoid false memory leaks reported by the MFC framework;
* http://codexpert.ro/blog/2015/05/23/using-lambdas-in-mfc-applications-part-3-dealing-with-c-rest-sdk/
*/
web::json::value result = web::json::value::parse(utility::string_t(m_spRequest->responseText));
onSucceeded(result); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status
#else
onSucceeded(); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status
#endif
// break reference cycle, Remove sink from xml http request
// CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt)
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
else if (401 == m_spRequest->status && InitialRequest == m_eState)
{
oAuthLib::IAuthorizePtr spAuthorize;
if (SUCCEEDED(GetTokenServer(&spAuthorize)))
{
const HRESULT _hr = spAuthorize->raw_CanRetryImmediately(m_spRequest, m_bstrAccessToken);
_ASSERT(SUCCEEDED(_hr)); // per definition gibt es hier KEIN E_FAIL/E_NOTIMPL ...
if (S_FALSE == _hr)
{
/*
* der ERSTE request der ein 401 empfaengt bzw. ALLE folge requests, die beendet wurden OHNE das wir bereits ein NEUES GUELTIGES access_token haben, laufen hier rein.
* werden vom client bzw. den clients die requests schneller abgesetzt als ein ExchangeToken() mit gueltigem access_token zurueckkommt muss der second try gequeued werden.
*/
ASSERT(NULL == m_pRenewTokenAsync);
m_pRenewTokenAsync = DYNAMIC_DOWNCAST(CoAuthRenewTokenAsync, RUNTIME_CLASS(CoAuthRenewTokenAsync)->CreateObject());
ASSERT(1 == m_pRenewTokenAsync->m_dwRef);
/*
* dieses object kuemmert sich transparent und OHNE jegliches zutun des programmieres
* darum das es einen pThis->onSucceeded() bzw. pThis->onFailed(); gibt
* diese referenz MUSS VOR dem aufruf von ::Init() gelockt anschliessend freigegeben UND NICHT gespeichert werden!
* Hinweis: ein per CRunntimeClass::CreateObject()) erzeugtes object hat initial 1 == CCmdTarget::m_dwRef
*/
{
oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback)));
ASSERT(CCmdTarget::m_dwRef == dwRef + 1);
m_pRenewTokenAsync->Init(spAuthorize, spCallback);
ASSERT(CCmdTarget::m_dwRef == dwRef + 2);
}
}
else
{
/*
* wir haben bereits ein NEUES GUELTIGES access_token empfangen.
* wir koennen diesen request SOFORT neu anstossen. MUSS NATUERLICH ASYNC sein.
*/
// wir loeschen das alte/unbrauchbare access_token aus dem initialen request
m_bstrAccessToken.Empty();
// mit IRenewCallback::Continue() wird der m_spRequest NEU initialisiert und indirekt ueber IWorkflow::AuthorizeRequest() wieder authorisiert.
oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback)));
spCallback->Continue();
// here we go: NEUES GUELTIGES access_token
ASSERT(0 < m_bstrAccessToken.Length());
}
}
else
{
// saudummer zustand wir koennen den fehler NICHT an den aufrufer liefern
// ohne Workflow object geht nix da machen wir ganz ALLGEMEIN schluss
m_eState = Finish;
onFailed();
// break reference cycle, Remove sink from xml http request
// CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt)
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
}
else
{
// IRGENDEIN (unbehandelter) http-status
m_eState = Finish;
onFailed();
// break reference cycle
// Remove sink from xml http request, hie faellt evtl. die letzte referenz
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
}
break;
default:
TRACE2(" logical state: %d, m_spRequest->readyState: %d\n", m_eState, m_spRequest->readyState);
break;
}
}
catch (const _com_error& e)
{
TRACE0("CoAuthServiceCall::ReadyStateChange(): ignore exception keep system stable!!!\n");
}
ExternalRelease(); // unlock your instance
}
void WebLoadManager::onFailed(QNetworkReply::NetworkError error) {
onFailed(qobject_cast<QNetworkReply*>(QObject::sender()));
}
void LocationManager::onFinished(QNetworkReply *reply) {
if (!manager) return;
if (reply->error() != QNetworkReply::NoError) return onFailed(reply);
QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
if (statusCode.isValid()) {
int status = statusCode.toInt();
if (status == 301 || status == 302) {
QString loc = reply->header(QNetworkRequest::LocationHeader).toString();
if (!loc.isEmpty()) {
QMap<QNetworkReply*, LocationData*>::iterator i = dataLoadings.find(reply);
if (i != dataLoadings.cend()) {
LocationData *d = i.value();
if (serverRedirects.constFind(d) == serverRedirects.cend()) {
serverRedirects.insert(d, 1);
} else if (++serverRedirects[d] > MaxHttpRedirects) {
DEBUG_LOG(("Network Error: Too many HTTP redirects in onFinished() for image link: %1").arg(loc));
return onFailed(reply);
}
dataLoadings.erase(i);
dataLoadings.insert(manager->get(QNetworkRequest(loc)), d);
return;
} else if ((i = imageLoadings.find(reply)) != imageLoadings.cend()) {
LocationData *d = i.value();
if (serverRedirects.constFind(d) == serverRedirects.cend()) {
serverRedirects.insert(d, 1);
} else if (++serverRedirects[d] > MaxHttpRedirects) {
DEBUG_LOG(("Network Error: Too many HTTP redirects in onFinished() for image link: %1").arg(loc));
return onFailed(reply);
}
imageLoadings.erase(i);
imageLoadings.insert(manager->get(QNetworkRequest(loc)), d);
return;
}
}
}
if (status != 200) {
DEBUG_LOG(("Network Error: Bad HTTP status received in onFinished() for image link: %1").arg(status));
return onFailed(reply);
}
}
LocationData *d = 0;
QMap<QNetworkReply*, LocationData*>::iterator i = dataLoadings.find(reply);
if (i != dataLoadings.cend()) {
d = i.value();
dataLoadings.erase(i);
QJsonParseError e;
QJsonDocument doc = QJsonDocument::fromJson(reply->readAll(), &e);
if (e.error != QJsonParseError::NoError) {
DEBUG_LOG(("JSON Error: Bad json received in onFinished() for image link"));
return onFailed(reply);
}
failed(d);
if (App::main()) App::main()->update();
} else {
i = imageLoadings.find(reply);
if (i != imageLoadings.cend()) {
d = i.value();
imageLoadings.erase(i);
QPixmap thumb;
QByteArray format;
QByteArray data(reply->readAll());
{
QBuffer buffer(&data);
QImageReader reader(&buffer);
#ifndef OS_MAC_OLD
reader.setAutoTransform(true);
#endif // OS_MAC_OLD
thumb = QPixmap::fromImageReader(&reader, Qt::ColorOnly);
format = reader.format();
thumb.setDevicePixelRatio(cRetinaFactor());
if (format.isEmpty()) format = QByteArray("JPG");
}
d->loading = false;
d->thumb = thumb.isNull() ? (*notLoadedPlaceholder) : ImagePtr(thumb, format);
serverRedirects.remove(d);
if (App::main()) App::main()->update();
}
}
}
const Future<T>& onFailed(_Deferred<F>&& deferred) const
{
return onFailed(std::function<void(const std::string&)>(deferred));
}
