File indexing completed on 2024-05-05 04:42:57
0001 /* 0002 SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org> 0003 0004 SPDX-License-Identifier: LGPL-2.0-or-later 0005 */ 0006 0007 #include "overpassquerymanager.h" 0008 #include "overpassquery.h" 0009 0010 #include <QDateTime> 0011 #include <QNetworkAccessManager> 0012 #include <QNetworkDiskCache> 0013 #include <QNetworkReply> 0014 #include <QStandardPaths> 0015 #include <QTimer> 0016 #include <QUrl> 0017 #include <QUrlQuery> 0018 0019 #include <chrono> 0020 #include <deque> 0021 0022 using namespace OSM; 0023 0024 namespace OSM { 0025 struct OverpassQueryTask { 0026 OverpassQuery *query = nullptr; 0027 QRectF bbox; 0028 bool forceReload = false; 0029 }; 0030 0031 struct OverpassQueryExecutor { 0032 QUrl endpoint; 0033 std::chrono::seconds cooldownTime = std::chrono::seconds(3); 0034 QDateTime nextSlot; 0035 std::unique_ptr<OverpassQueryTask> task; 0036 }; 0037 0038 class OverpassQueryManagerPrivate { 0039 public: 0040 void executeTasks(); 0041 void taskFinished(OverpassQueryExecutor *executor, QNetworkReply *reply); 0042 void checkQueryFinished(OverpassQuery *query) const; 0043 void cancelQuery(OverpassQuery *query); 0044 0045 OverpassQueryManager *q; 0046 QNetworkAccessManager *m_nam; 0047 QTimer *m_nextTaskTimer; 0048 std::vector<OverpassQueryExecutor> m_executors; 0049 std::deque<std::unique_ptr<OverpassQueryTask>> m_tasks; 0050 }; 0051 } 0052 0053 static const char* executor_configs[] = { 0054 "https://overpass-api.de/api/interpreter", 0055 "https://1.overpass.kumi.systems/api/interpreter", 0056 "https://2.overpass.kumi.systems/api/interpreter", 0057 "https://3.overpass.kumi.systems/api/interpreter", 0058 "https://4.overpass.kumi.systems/api/interpreter", 0059 }; 0060 0061 OverpassQueryManager::OverpassQueryManager(QObject *parent) 0062 : QObject(parent) 0063 , d(new OverpassQueryManagerPrivate) 0064 { 0065 d->q = this; 0066 d->m_nam = new QNetworkAccessManager(this); 0067 d->m_nam->setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy); 0068 d->m_nam->setStrictTransportSecurityEnabled(true); 0069 d->m_nam->enableStrictTransportSecurityStore(true, QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QLatin1String("/org.kde.osm/hsts/")); 0070 0071 auto diskCache = new QNetworkDiskCache; 0072 diskCache->setCacheDirectory(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QLatin1String("/org.kde.osm/overpass-cache/")); 0073 diskCache->setMaximumCacheSize(1'000'000'000); // 1GB 0074 d->m_nam->setCache(diskCache); 0075 0076 d->m_nextTaskTimer = new QTimer(this); 0077 d->m_nextTaskTimer->setSingleShot(true); 0078 connect(d->m_nextTaskTimer, &QTimer::timeout, this, [this]() { d->executeTasks(); }); 0079 0080 for (const auto &config : executor_configs) { 0081 OverpassQueryExecutor executor; 0082 executor.endpoint = QUrl(QString::fromUtf8(config)); 0083 d->m_executors.push_back(std::move(executor)); 0084 } 0085 } 0086 0087 OverpassQueryManager::~OverpassQueryManager() = default; 0088 0089 void OverpassQueryManager::execute(OverpassQuery *query) 0090 { 0091 // validate input 0092 if (query->query().isEmpty() || query->boundingBox().isNull() || !query->boundingBox().isValid() || query->tileSize().isNull() || !query->tileSize().isValid()) { 0093 query->m_error = OverpassQuery::QueryError; 0094 QTimer::singleShot(0, query, &OverpassQuery::finished); 0095 return; 0096 } 0097 0098 // generate tasks for the query 0099 const auto xTileCount = std::max<int>(1, query->boundingBox().width() / query->tileSize().width()); 0100 const auto yTileCount = std::max<int>(1, query->boundingBox().height() / query->tileSize().height()); 0101 const auto xTileSize = query->boundingBox().width() / xTileCount; 0102 const auto yTileSize = query->boundingBox().height() / yTileCount; 0103 qDebug() << "Creating" << xTileCount * yTileCount << "tasks with tile size" << xTileSize << "x" << yTileSize; 0104 for (auto x = 0; x < xTileCount; ++x) { 0105 for (auto y = 0; y < yTileCount; ++y) { 0106 auto task = std::make_unique<OverpassQueryTask>(); 0107 task->query = query; 0108 task->bbox = { query->boundingBox().x() + x * xTileSize, query->boundingBox().y() + y * yTileSize, xTileSize, yTileSize }; 0109 d->m_tasks.push_back(std::move(task)); 0110 } 0111 } 0112 0113 d->executeTasks(); 0114 } 0115 0116 void OverpassQueryManagerPrivate::executeTasks() 0117 { 0118 const auto now = QDateTime::currentDateTimeUtc(); 0119 std::chrono::seconds nextSlot = std::chrono::hours(1); 0120 0121 for (auto &executor : m_executors) { 0122 if (m_tasks.empty()) { // nothing to do 0123 return; 0124 } 0125 0126 if (executor.task) { // executor is busy already 0127 continue; 0128 } 0129 0130 if (executor.nextSlot > now) { // executor is still in rate limit cooldown 0131 nextSlot = std::min(std::chrono::seconds(now.secsTo(executor.nextSlot)), nextSlot); 0132 nextSlot += std::chrono::seconds(1); // for msec rounding errors that would other wise give us a busy loop 0133 if (m_tasks.front()->forceReload) { 0134 continue; 0135 } 0136 } 0137 0138 executor.task = std::move(m_tasks.front()); 0139 m_tasks.pop_front(); 0140 0141 // actually execute query 0142 auto url = executor.endpoint; 0143 QUrlQuery params; 0144 params.addQueryItem(QStringLiteral("data"), executor.task->query->query(executor.task->bbox)); 0145 url.setQuery(params); 0146 QNetworkRequest req(url); 0147 req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, executor.task->forceReload ? QNetworkRequest::PreferNetwork : QNetworkRequest::AlwaysCache); 0148 auto reply = m_nam->get(req); 0149 // TODO enable stream parsing for XML replies by connecting to QNetworkReply::readyRead 0150 QObject::connect(reply, &QNetworkReply::finished, q, [this, &executor, reply]() { 0151 taskFinished(&executor, reply); 0152 reply->deleteLater(); 0153 }); 0154 } 0155 0156 m_nextTaskTimer->start(nextSlot); 0157 } 0158 0159 void OverpassQueryManagerPrivate::taskFinished(OverpassQueryExecutor *executor, QNetworkReply *reply) 0160 { 0161 auto query = executor->task->query; 0162 if (reply->error() == QNetworkReply::UnknownContentError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 429) { 0163 // rate limiting error 0164 executor->cooldownTime *= 2; 0165 qDebug() << "rate limit error, increasing cooldown time to" << executor->cooldownTime.count() << "seconds"; 0166 m_tasks.push_back(std::move(executor->task)); 0167 } else if (reply->error() == QNetworkReply::ContentNotFoundError && !executor->task->forceReload) { 0168 // cache miss, retry from network 0169 executor->task->forceReload = true; 0170 m_tasks.push_back(std::move(executor->task)); 0171 } else if (reply->error() != QNetworkReply::NoError) { 0172 // TODO disable affected executors here and reschedule the failed task, rather than cancelling entirely 0173 qDebug() << reply->error() << reply->errorString() << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute) << reply->readAll(); 0174 query->m_error = OverpassQuery::NetworkError; 0175 cancelQuery(query); 0176 } else { 0177 const auto queryError = query->processReply(reply); 0178 // on query timeout, break up the task in 4 sub-tasks, if we are allowed to 0179 if (queryError == OverpassQuery::QueryTimeout 0180 && executor->task->bbox.width() > query->minimumTileSize().width() 0181 && executor->task->bbox.height() > query->minimumTileSize().height()) 0182 { 0183 qDebug() << "Splitting task due to query timeout:" << executor->task->bbox; 0184 const auto xTileSize = executor->task->bbox.width() / 2.0; 0185 const auto yTileSize = executor->task->bbox.height() / 2.0; 0186 for (auto x = 0; x < 2; ++x) { 0187 for (auto y = 0; y < 2; ++y) { 0188 auto task = std::make_unique<OverpassQueryTask>(); 0189 task->query = query; 0190 task->bbox = { executor->task->bbox.x() + x * xTileSize, executor->task->bbox.y() + y * yTileSize, xTileSize, yTileSize }; 0191 m_tasks.push_back(std::move(task)); 0192 } 0193 } 0194 } 0195 else if (queryError != OverpassQuery::NoError) { 0196 if (executor->task->forceReload) { 0197 query->m_error = queryError; 0198 cancelQuery(query); 0199 } else { 0200 // query error in cached result, retry 0201 executor->task->forceReload = true; 0202 m_tasks.push_back(std::move(executor->task)); 0203 } 0204 } 0205 } 0206 0207 // free the executor for the next query 0208 executor->task.reset(); 0209 executor->nextSlot = QDateTime::currentDateTimeUtc().addSecs(executor->cooldownTime.count()); 0210 0211 checkQueryFinished(query); 0212 executeTasks(); 0213 } 0214 0215 void OverpassQueryManagerPrivate::checkQueryFinished(OverpassQuery *query) const 0216 { 0217 if (std::any_of(m_executors.begin(), m_executors.end(), [query](const auto &executor) { return executor.task && executor.task->query == query; }) 0218 || std::any_of(m_tasks.begin(), m_tasks.end(), [query](const auto &task) { return task->query == query; })) 0219 return; 0220 Q_EMIT query->finished(); 0221 } 0222 0223 void OverpassQueryManagerPrivate::cancelQuery(OverpassQuery *query) 0224 { 0225 qDebug() << "cancelling query..."; 0226 m_tasks.erase(std::remove_if(m_tasks.begin(), m_tasks.end(), [query](const auto &task) { return task->query == query; }), m_tasks.end()); 0227 checkQueryFinished(query); 0228 }