mirror of https://github.com/tstack/lnav
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
251 lines
7.1 KiB
C++
251 lines
7.1 KiB
C++
/**
|
|
* Copyright (c) 2015, Timothy Stack
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* * Neither the name of Timothy Stack nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* @file curl_looper.hh
|
|
*/
|
|
|
|
#ifndef curl_looper_hh
|
|
#define curl_looper_hh
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#ifndef HAVE_LIBCURL
|
|
|
|
typedef int CURLcode;
|
|
|
|
class curl_request {
|
|
public:
|
|
curl_request(const std::string &name) {
|
|
};
|
|
};
|
|
|
|
class curl_looper {
|
|
public:
|
|
void start() { };
|
|
void stop() { };
|
|
void add_request(curl_request *cr) { };
|
|
void close_request(const std::string &name) { };
|
|
void process_all() { };
|
|
};
|
|
|
|
#else
|
|
#include <curl/curl.h>
|
|
|
|
#include "auto_mem.hh"
|
|
#include "base/lnav_log.hh"
|
|
#include "lnav_util.hh"
|
|
#include "base/pthreadpp.hh"
|
|
|
|
class curl_request {
|
|
public:
|
|
curl_request(const std::string &name)
|
|
: cr_name(name),
|
|
cr_open(true),
|
|
cr_handle(curl_easy_cleanup),
|
|
cr_completions(0) {
|
|
this->cr_handle.reset(curl_easy_init());
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_NOSIGNAL, 1);
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_ERRORBUFFER, this->cr_error_buffer);
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_DEBUGFUNCTION, debug_cb);
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_DEBUGDATA, this);
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_VERBOSE, 1);
|
|
if (getenv("SSH_AUTH_SOCK") != NULL) {
|
|
curl_easy_setopt(this->cr_handle, CURLOPT_SSH_AUTH_TYPES,
|
|
#ifdef CURLSSH_AUTH_AGENT
|
|
CURLSSH_AUTH_AGENT|
|
|
#endif
|
|
CURLSSH_AUTH_PASSWORD);
|
|
}
|
|
};
|
|
|
|
virtual ~curl_request() {
|
|
|
|
};
|
|
|
|
const std::string &get_name() const {
|
|
return this->cr_name;
|
|
};
|
|
|
|
virtual void close() {
|
|
this->cr_open = false;
|
|
};
|
|
|
|
bool is_open() {
|
|
return this->cr_open;
|
|
};
|
|
|
|
CURL *get_handle() const {
|
|
return this->cr_handle;
|
|
};
|
|
|
|
int get_completions() const {
|
|
return this->cr_completions;
|
|
};
|
|
|
|
virtual long complete(CURLcode result) {
|
|
double total_time = 0, download_size = 0, download_speed = 0;
|
|
|
|
this->cr_completions += 1;
|
|
curl_easy_getinfo(this->cr_handle, CURLINFO_TOTAL_TIME, &total_time);
|
|
log_debug("%s: total_time=%f", this->cr_name.c_str(), total_time);
|
|
curl_easy_getinfo(this->cr_handle, CURLINFO_SIZE_DOWNLOAD, &download_size);
|
|
log_debug("%s: download_size=%f", this->cr_name.c_str(), download_size);
|
|
curl_easy_getinfo(this->cr_handle, CURLINFO_SPEED_DOWNLOAD, &download_speed);
|
|
log_debug("%s: download_speed=%f", this->cr_name.c_str(), download_speed);
|
|
|
|
return -1;
|
|
};
|
|
|
|
protected:
|
|
|
|
static int debug_cb(CURL *handle,
|
|
curl_infotype type,
|
|
char *data,
|
|
size_t size,
|
|
void *userp);
|
|
|
|
const std::string cr_name;
|
|
bool cr_open;
|
|
auto_mem<CURL> cr_handle;
|
|
char cr_error_buffer[CURL_ERROR_SIZE];
|
|
int cr_completions;
|
|
};
|
|
|
|
class curl_looper {
|
|
public:
|
|
curl_looper()
|
|
: cl_started(false),
|
|
cl_looping(true),
|
|
cl_curl_multi(curl_multi_cleanup) {
|
|
this->cl_curl_multi.reset(curl_multi_init());
|
|
pthread_mutex_init(&this->cl_mutex, NULL);
|
|
pthread_cond_init(&this->cl_cond, NULL);
|
|
};
|
|
|
|
~curl_looper() {
|
|
this->stop();
|
|
pthread_cond_destroy(&this->cl_cond);
|
|
pthread_mutex_destroy(&this->cl_mutex);
|
|
}
|
|
|
|
void start() {
|
|
if (pthread_create(&this->cl_thread, NULL, trampoline, this) == 0) {
|
|
this->cl_started = true;
|
|
}
|
|
};
|
|
|
|
void stop() {
|
|
if (this->cl_started) {
|
|
void *result;
|
|
|
|
this->cl_looping = false;
|
|
{
|
|
mutex_guard mg(this->cl_mutex);
|
|
|
|
pthread_cond_broadcast(&this->cl_cond);
|
|
}
|
|
log_debug("waiting for curl_looper thread");
|
|
pthread_join(this->cl_thread, &result);
|
|
log_debug("curl_looper thread joined");
|
|
this->cl_started = false;
|
|
}
|
|
};
|
|
|
|
void process_all() {
|
|
this->check_for_new_requests();
|
|
|
|
this->requeue_requests(LONG_MAX);
|
|
|
|
while (!this->cl_handle_to_request.empty()) {
|
|
this->perform_io();
|
|
|
|
this->check_for_finished_requests();
|
|
}
|
|
};
|
|
|
|
void add_request(curl_request *cr) {
|
|
mutex_guard mg(this->cl_mutex);
|
|
|
|
require(cr != NULL);
|
|
|
|
this->cl_all_requests.push_back(cr);
|
|
this->cl_new_requests.push_back(cr);
|
|
pthread_cond_broadcast(&this->cl_cond);
|
|
};
|
|
|
|
void close_request(const std::string &name) {
|
|
mutex_guard mg(this->cl_mutex);
|
|
|
|
this->cl_close_requests.push_back(name);
|
|
pthread_cond_broadcast(&this->cl_cond);
|
|
};
|
|
|
|
private:
|
|
|
|
void *run();
|
|
void loop_body();
|
|
void perform_io();
|
|
void check_for_new_requests();
|
|
void check_for_finished_requests();
|
|
void requeue_requests(mstime_t up_to_time);
|
|
|
|
int compute_timeout(mstime_t current_time) const {
|
|
int retval = 1000;
|
|
|
|
if (!this->cl_poll_queue.empty()) {
|
|
retval = std::max(
|
|
(mstime_t) 1,
|
|
this->cl_poll_queue.front().first - current_time);
|
|
}
|
|
|
|
ensure(retval > 0);
|
|
|
|
return retval;
|
|
};
|
|
|
|
static void *trampoline(void *arg);
|
|
|
|
bool cl_started;
|
|
pthread_t cl_thread;
|
|
volatile bool cl_looping;
|
|
auto_mem<CURLM> cl_curl_multi;
|
|
pthread_mutex_t cl_mutex;
|
|
pthread_cond_t cl_cond;
|
|
std::vector<curl_request *> cl_all_requests;
|
|
std::vector<curl_request *> cl_new_requests;
|
|
std::vector<std::string> cl_close_requests;
|
|
std::map<CURL *, curl_request *> cl_handle_to_request;
|
|
std::vector<std::pair<mstime_t, curl_request *> > cl_poll_queue;
|
|
|
|
};
|
|
#endif
|
|
|
|
#endif
|