src/network/core/http_shared.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /**
   9  * @file http_shared.h Shared functions for implementations of HTTP requests.
  10  */
  11
  12 #ifndef NETWORK_CORE_HTTP_SHARED_H
  13 #define NETWORK_CORE_HTTP_SHARED_H
  14
  15 #include "http.h"
  16
  17 #include <condition_variable>
  18 #include <mutex>
  19 #include <vector>
  20
  21 /** Converts a HTTPCallback to a Thread-Safe variant. */
  22 class HTTPThreadSafeCallback {
  23 private:
  24         /** Entries on the queue for later handling. */
  25         class Callback {
  26         public:
  27                 Callback(std::unique_ptr<char[]> data, size_t length) : data(std::move(data)), length(length), failure(false) {}
  28                 Callback() : data(nullptr), length(0), failure(true) {}
  29
  30                 std::unique_ptr<char[]> data;
  31                 size_t length;
  32                 bool failure;
  33         };
  34
  35 public:
  36         /**
  37          * Similar to HTTPCallback::OnFailure, but thread-safe.
  38          */
  39         void OnFailure()
  40         {
  41                 std::lock_guard<std::mutex> lock(this->mutex);
  42                 this->queue.emplace_back();
  43         }
  44
  45         /**
  46          * Similar to HTTPCallback::OnReceiveData, but thread-safe.
  47          */
  48         void OnReceiveData(std::unique_ptr<char[]> data, size_t length)
  49         {
  50                 std::lock_guard<std::mutex> lock(this->mutex);
  51                 this->queue.emplace_back(std::move(data), length);
  52         }
  53
  54         /**
  55          * Process everything on the queue.
  56          *
  57          * Should be called from the Game Thread.
  58          */
  59         void HandleQueue()
  60         {
  61                 this->cancelled = callback->IsCancelled();
  62
  63                 std::lock_guard<std::mutex> lock(this->mutex);
  64
  65                 for (auto &item : this->queue) {
  66                         if (item.failure) {
  67                                 this->callback->OnFailure();
  68                         } else {
  69                                 this->callback->OnReceiveData(std::move(item.data), item.length);
  70                         }
  71                 }
  72
  73                 this->queue.clear();
  74                 this->queue_cv.notify_all();
  75         }
  76
  77         /**
  78          * Wait till the queue is dequeued, or a condition is met.
  79          * @param condition Condition functor.
  80          */
  81         template <typename T>
  82         void WaitTillEmptyOrCondition(T condition)
  83         {
  84                 std::unique_lock<std::mutex> lock(this->mutex);
  85
  86                 while (!(queue.empty() || condition())) {
  87                         this->queue_cv.wait(lock);
  88                 }
  89         }
  90
  91         /**
  92          * Check if the queue is empty.
  93          */
  94         bool IsQueueEmpty()
  95         {
  96                 std::lock_guard<std::mutex> lock(this->mutex);
  97                 return this->queue.empty();
  98         }
  99
 100         HTTPThreadSafeCallback(HTTPCallback *callback) : callback(callback) {}
 101
 102         ~HTTPThreadSafeCallback()
 103         {
 104                 std::lock_guard<std::mutex> lock(this->mutex);
 105
 106                 /* Clear the list and notify explicitly. */
 107                 queue.clear();
 108                 queue_cv.notify_all();
 109         }
 110
 111         std::atomic<bool> cancelled = false;
 112
 113 private:
 114         HTTPCallback *callback; ///< The callback to send data back on.
 115         std::mutex mutex; ///< Mutex to protect the queue.
 116         std::vector<Callback> queue; ///< Queue of data to send back.
 117         std::condition_variable queue_cv; ///< Condition variable to wait for the queue to be empty.
 118 };
 119
 120 #endif /* NETWORK_CORE_HTTP_SHARED_H */