167 lines
4.2 KiB
C++
167 lines
4.2 KiB
C++
#include "request.hpp"
|
|
|
|
#include <queue>
|
|
#include <forward_list>
|
|
#include <pthread.h>
|
|
|
|
#include <llmr/platform/platform.hpp>
|
|
|
|
using namespace llmr::platform;
|
|
|
|
class Threadpool;
|
|
|
|
class Worker {
|
|
public:
|
|
Worker(Threadpool& pool);
|
|
|
|
static void *loop(void *ptr) {
|
|
pthread_setname_np("worker");
|
|
static_cast<Worker *>(ptr)->loop();
|
|
pthread_exit(nullptr);
|
|
}
|
|
|
|
void loop();
|
|
|
|
private:
|
|
Threadpool& pool;
|
|
pthread_t thread;
|
|
};
|
|
|
|
|
|
class Threadpool {
|
|
friend class Worker;
|
|
|
|
public:
|
|
typedef void (*Callback)(void *);
|
|
Threadpool(Callback callback);
|
|
|
|
void add(void *data);
|
|
|
|
private:
|
|
pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
|
|
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
|
|
std::forward_list<Worker> workers;
|
|
Callback callback;
|
|
std::queue<void *> tasks;
|
|
};
|
|
|
|
|
|
Threadpool::Threadpool(Callback callback)
|
|
: callback(callback) {
|
|
const int worker_count = 4;
|
|
fprintf(stderr, "workers: %d\n", worker_count);
|
|
for (int i = 0; i < worker_count; i++) {
|
|
workers.emplace_front(*this);
|
|
}
|
|
}
|
|
|
|
void Threadpool::add(void *data) {
|
|
pthread_mutex_lock(&mutex);
|
|
tasks.push(data);
|
|
pthread_mutex_unlock(&mutex);
|
|
pthread_cond_signal(&condition);
|
|
}
|
|
|
|
Worker::Worker(Threadpool& pool)
|
|
: pool(pool) {
|
|
pthread_create(&thread, nullptr, loop, (void *)this);
|
|
}
|
|
|
|
void Worker::loop() {
|
|
pthread_mutex_lock(&pool.mutex);
|
|
while (true) {
|
|
if (pool.tasks.size()) {
|
|
void *task = pool.tasks.front();
|
|
pool.tasks.pop();
|
|
pthread_mutex_unlock(&pool.mutex);
|
|
pool.callback(task);
|
|
pthread_mutex_lock(&pool.mutex);
|
|
} else {
|
|
pthread_cond_wait(&pool.condition, &pool.mutex);
|
|
}
|
|
}
|
|
}
|
|
|
|
Threadpool *request_pool = nullptr;
|
|
CURLSH *curl_share = nullptr;
|
|
pthread_mutex_t curl_share_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
|
|
void curl_share_lock(CURL *, curl_lock_data, curl_lock_access, void *) {
|
|
pthread_mutex_lock(&curl_share_mutex);
|
|
}
|
|
|
|
void curl_share_unlock(CURL *, curl_lock_data, void *) {
|
|
pthread_mutex_unlock(&curl_share_mutex);
|
|
}
|
|
|
|
|
|
Request::Request(std::string url, std::function<void(platform::Response&)> bg, std::function<void()> fg)
|
|
: done(false),
|
|
cancelled(false),
|
|
url(url),
|
|
background_function(bg),
|
|
foreground_callback(fg) {
|
|
if (!request_pool) {
|
|
request_pool = new Threadpool(request);
|
|
}
|
|
if (!curl_share) {
|
|
// curl init
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
curl_share = curl_share_init();
|
|
curl_share_setopt(curl_share, CURLSHOPT_LOCKFUNC, curl_share_lock);
|
|
curl_share_setopt(curl_share, CURLSHOPT_UNLOCKFUNC, curl_share_unlock);
|
|
}
|
|
request_pool->add(this);
|
|
}
|
|
|
|
|
|
size_t Request::write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
|
|
((std::string *)userp)->append((char *)contents, size * nmemb);
|
|
return size * nmemb;
|
|
}
|
|
|
|
|
|
int Request::progress_callback(void *ptr, double dltotal, double dlnow, double ultotal, double ulnow) {
|
|
Request *req = static_cast<Request *>(ptr);
|
|
bool cancel = req->cancelled;
|
|
if (cancel) {
|
|
fprintf(stderr, "cancel download %s\n", req->url.c_str());
|
|
}
|
|
return cancel;
|
|
}
|
|
|
|
void Request::request(void *ptr) {
|
|
Request *req = static_cast<Request *>(ptr);
|
|
Response res;
|
|
|
|
fprintf(stderr, "[%p] request %s\n", pthread_self(), req->url.c_str());
|
|
|
|
// TODO: use curl multi to be able to cancel, or to
|
|
|
|
CURL *curl = curl_easy_init();
|
|
CURLcode code;
|
|
|
|
curl_easy_setopt(curl, CURLOPT_URL, req->url.c_str());
|
|
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
|
|
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &res.body);
|
|
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
|
|
curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, req);
|
|
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
|
|
curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "deflate");
|
|
curl_easy_setopt(curl, CURLOPT_SHARE, curl_share);
|
|
code = curl_easy_perform(curl);
|
|
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &res.code);
|
|
curl_easy_cleanup(curl);
|
|
|
|
if (code != CURLE_ABORTED_BY_CALLBACK) {
|
|
req->background_function(res);
|
|
}
|
|
|
|
req->done = true;
|
|
}
|
|
|
|
void Request::cancel() {
|
|
cancelled = true;
|
|
}
|