37 #include <XrdVersion.hh>
39 #include <curl/curl.h>
40 #include <openssl/bio.h>
41 #include <openssl/evp.h>
48 #include <sys/syscall.h>
49 #include <sys/types.h>
60 #include <system_error>
65 thread_local std::vector<CURL*> HandlerQueue::m_handles;
66 std::atomic<unsigned> CurlWorker::m_maintenance_period = 5;
67 std::vector<std::unique_ptr<XrdClHttp::CurlWorker>> CurlWorker::m_workers;
68 std::mutex CurlWorker::m_workers_mutex;
71 std::atomic<uint64_t> CurlWorker::m_conncall_errors = 0;
72 std::atomic<uint64_t> CurlWorker::m_conncall_req = 0;
73 std::atomic<uint64_t> CurlWorker::m_conncall_success = 0;
74 std::atomic<uint64_t> CurlWorker::m_conncall_timeout = 0;
75 decltype(CurlWorker::m_ops) CurlWorker::m_ops = {};
76 std::vector<std::atomic<std::chrono::system_clock::rep>*> CurlWorker::m_workers_last_completed_cycle;
77 std::vector<std::atomic<std::chrono::system_clock::rep>*> CurlWorker::m_workers_oldest_op;
78 std::mutex CurlWorker::m_worker_stats_mutex;
81 std::atomic<uint64_t> HandlerQueue::m_ops_consumed = 0;
82 std::atomic<uint64_t> HandlerQueue::m_ops_produced = 0;
83 std::atomic<uint64_t> HandlerQueue::m_ops_rejected = 0;
86 CurlWorker::initcontrol CurlWorker::m_initcontrol;
96 #if defined(__APPLE__)
97 uint64_t pth_threadid;
98 pthread_threadid_np(pthread_self(), &pth_threadid);
100 #elif defined(__linux__)
105 return syscall(SYS_gettid);
114 return (status < 100) || (status >= 400);
123 if (!env->GetString(
"BearerToken", token) || token.empty()) {
124 env->ImportString(
"BearerToken",
"BEARER_TOKEN");
125 env->GetString(
"BearerToken", token);
127 if (!token.empty()) {
132 std::string token_file;
133 if (!env->GetString(
"BearerTokenFile", token_file) || token_file.empty()) {
134 env->ImportString(
"BearerTokenFile",
"BEARER_TOKEN_FILE");
135 env->GetString(
"BearerTokenFile", token_file);
137 if (token_file.empty())
return {};
139 std::ifstream input(token_file);
140 if (!input)
return {};
147 bool hasX509Credential,
150 if(protocols.empty())
return hasBearerToken;
152 std::vector<std::string> requested;
154 for(
auto protocol : requested)
157 std::transform(protocol.begin(), protocol.end(), protocol.begin(),
158 [](
unsigned char c) { return std::tolower(c); });
159 if(protocol ==
"gsi" && hasX509Credential)
return false;
160 if(protocol ==
"ztn" && hasBearerToken)
return true;
167 std::vector<std::pair<std::string, std::string>> &headers,
170 if(url.
GetParams().count(
"authz"))
return;
171 for(
const auto &header : headers)
173 if(header.first ==
"Authorization")
return;
177 if(token.empty())
return;
179 bool hasX509Credential =
false;
184 std::string certificate;
186 env->GetInt(
"HttpDisableX509", disableX509)
188 && env->GetString(
"HttpClientCertFile", certificate)
189 && !certificate.empty();
192 const char *configuredProtocols = std::getenv(
"XrdSecPROTOCOL");
194 hasX509Credential,
true))
202 "Injecting bearer token from environment for %s",
205 headers.emplace_back(
"Authorization",
"Bearer " + token);
280 case CURLE_COULDNT_RESOLVE_PROXY:
281 case CURLE_COULDNT_RESOLVE_HOST:
283 case CURLE_LOGIN_DENIED:
288 case CURLE_REMOTE_ACCESS_DENIED:
290 case CURLE_SSL_CONNECT_ERROR:
291 case CURLE_SSL_ENGINE_NOTFOUND:
292 case CURLE_SSL_ENGINE_SETFAILED:
293 case CURLE_SSL_CERTPROBLEM:
294 case CURLE_SSL_CIPHER:
296 case CURLE_SSL_SHUTDOWN_FAILED:
297 case CURLE_SSL_CRL_BADFILE:
298 case CURLE_SSL_ISSUER_ERROR:
299 case CURLE_SSL_CACERT:
303 case CURLE_SEND_ERROR:
304 case CURLE_RECV_ERROR:
306 case CURLE_COULDNT_CONNECT:
307 case CURLE_GOT_NOTHING:
309 case CURLE_OPERATION_TIMEDOUT:
310 #ifdef HAVE_XPROTOCOL_TIMEREXPIRED
315 case CURLE_UNSUPPORTED_PROTOCOL:
316 case CURLE_NOT_BUILT_IN:
318 case CURLE_FAILED_INIT:
320 case CURLE_URL_MALFORMAT:
326 case CURLE_PARTIAL_FILE:
331 case CURLE_READ_ERROR:
332 case CURLE_WRITE_ERROR:
334 case CURLE_RANGE_ERROR:
335 case CURLE_BAD_CONTENT_ENCODING:
337 case CURLE_TOO_MANY_REDIRECTS:
345 std::string_view input,
346 std::array<unsigned char, g_max_checksum_length> &output) {
347 if (input.size() > 4 * ((output.size() + 2) / 3)
348 || input.size() % 4 != 0)
350 if (input.size() == 0)
return true;
352 std::unique_ptr<BIO, decltype(&BIO_free_all)> b64(BIO_new(BIO_f_base64()), &BIO_free_all);
353 BIO_set_flags(b64.get(), BIO_FLAGS_BASE64_NO_NL);
354 std::unique_ptr<BIO, decltype(&BIO_free_all)> bmem(
355 BIO_new_mem_buf(
const_cast<char *
>(input.data()), input.size()), &BIO_free_all);
356 bmem.reset(BIO_push(b64.release(), bmem.release()));
359 size_t expectedLen =
static_cast<size_t>(input.size() * 0.75);
360 if (input[input.size() - 1] ==
'=') {
362 if (input[input.size() - 2] ==
'=') {
367 auto len = BIO_read(bmem.get(), &output[0], output.size());
369 if (len == -1 ||
static_cast<size_t>(len) != expectedLen)
return false;
381 if (m_recv_all_headers) {
382 m_recv_all_headers =
false;
383 m_recv_status_line =
false;
386 if (!m_recv_status_line) {
387 m_recv_status_line =
true;
389 std::stringstream ss(header_line);
392 m_resp_protocol = item;
395 m_status_code = std::stol(item);
399 if (m_status_code < 100 || m_status_code >= 600) {
403 auto cr_loc = item.find(
'\r');
404 if (cr_loc != std::string::npos) {
405 m_resp_message = item.substr(0, cr_loc);
407 m_resp_message = item;
412 if (header_line.empty() || header_line ==
"\n" || header_line ==
"\r\n") {
413 m_recv_all_headers =
true;
417 auto found = header_line.find(
":");
418 if (found == std::string::npos) {
422 std::string header_name = header_line.substr(0, found);
428 while (found < header_line.size()) {
429 if (header_line[found] !=
' ') {
break;}
432 std::string header_value = header_line.substr(found);
435 header_value.erase(header_value.find_last_not_of(
" \r\n\t") + 1);
439 auto iter = m_headers.find(header_name);
440 if (iter == m_headers.end()) {
441 m_headers.insert(iter, {header_name, {header_value}});
443 iter->second.push_back(header_value);
446 if (header_name ==
"Allow") {
447 std::string_view val(header_value);
448 while (!val.empty()) {
449 auto found = val.find(
',');
450 auto method = val.substr(0, found);
451 if (method ==
"PROPFIND") {
455 if (found == std::string_view::npos)
break;
456 val = val.substr(found + 1);
461 }
else if (header_name ==
"Last-Modified") {
463 if (strptime(header_value.c_str(),
"%a, %d %b %Y %H:%M:%S", &tm) !=
nullptr) {
464 m_modtime = timegm(&tm);
466 }
else if (header_name ==
"Content-Length") {
468 m_content_length = std::stoll(header_value);
473 else if (header_name ==
"Content-Type") {
474 std::string_view val(header_value);
475 auto found = val.find(
";");
476 auto first_type = val.substr(0, found);
477 m_multipart_byteranges = first_type ==
"multipart/byteranges";
478 if (m_multipart_byteranges) {
479 auto remainder = val.substr(found + 1);
480 found = remainder.find(
"boundary=");
481 if (found != std::string_view::npos) {
486 else if (header_name ==
"Content-Range") {
487 auto found = header_value.find(
" ");
488 if (found == std::string::npos) {
491 std::string range_unit = header_value.substr(0, found);
492 if (range_unit !=
"bytes") {
495 auto range_resp = header_value.substr(found + 1);
496 found = range_resp.find(
"/");
497 if (found == std::string::npos) {
500 auto incl_range = range_resp.substr(0, found);
501 found = incl_range.find(
"-");
502 if (found == std::string::npos) {
505 auto first_pos = incl_range.substr(0, found);
507 m_response_offset = std::stoll(first_pos);
511 auto last_pos = incl_range.substr(found + 1);
514 last_byte = std::stoll(last_pos);
518 m_content_length = last_byte - m_response_offset + 1;
520 else if (header_name ==
"Location") {
521 m_location = header_value;
522 }
else if (header_name ==
"Digest") {
525 else if (header_name ==
"Etag")
529 m_etag = header_value;
530 m_etag.erase(remove(m_etag.begin(), m_etag.end(),
'\"'), m_etag.end());
532 else if (header_name ==
"Cache-Control")
534 m_cache_control = header_value;
544 std::string_view view(digest);
545 std::array<unsigned char, g_max_checksum_length> checksum_value{};
546 std::string digest_lower;
547 while (!view.empty()) {
548 auto nextsep = view.find(
',');
549 auto entry = view.substr(0, nextsep);
550 if (nextsep == std::string_view::npos) {
553 view = view.substr(nextsep + 1);
555 nextsep = entry.find(
'=');
556 if (nextsep == std::string_view::npos)
continue;
557 auto name =
trim_view(entry.substr(0, nextsep));
558 auto value =
trim_view(entry.substr(nextsep + 1));
559 digest_lower.clear();
560 digest_lower.resize(name.size());
561 std::transform(name.begin(), name.end(), digest_lower.begin(), [](
unsigned char c) {
562 return std::tolower(c);
565 if (value.empty() || value.size() > 8)
return;
566 std::string padded(8 - value.size(),
'0');
567 padded.append(value.data(), value.size());
569 if (!checksum.
Set(padded.c_str(), padded.size()))
return;
571 reinterpret_cast<const unsigned char *
>(checksum.
Value),
573 info.
Set(type, checksum_value);
577 const size_t encodedSize = 4 * ((decodedSize + 2) / 3);
578 if (value.size() == encodedSize
581 info.
Set(type, checksum_value);
584 if (digest_lower ==
"adler" || digest_lower ==
"adler32") {
585 setHex32(ChecksumType::kADLER32);
586 }
else if (digest_lower ==
"crc32") {
590 if (value.size() == 8 && value[6] ==
'=' && value[7] ==
'=') {
591 setBase64(ChecksumType::kCRC32);
594 setHex32(ChecksumType::kCRC32);
595 }
else if (digest_lower ==
"md5") {
596 setBase64(ChecksumType::kMD5);
597 }
else if (digest_lower ==
"sha" || digest_lower ==
"sha1") {
598 setBase64(ChecksumType::kSHA1);
599 }
else if (digest_lower ==
"sha-256" || digest_lower ==
"sha256") {
600 setBase64(ChecksumType::kSHA256);
601 }
else if (digest_lower ==
"crc32c") {
606 if (value.size() == 8 && value[6] ==
'=' && value[7] ==
'=') {
607 setBase64(ChecksumType::kCRC32C);
610 setHex32(ChecksumType::kCRC32C);
619 case XrdClHttp::ChecksumType::kADLER32:
621 case XrdClHttp::ChecksumType::kCRC32:
623 case XrdClHttp::ChecksumType::kMD5:
625 case XrdClHttp::ChecksumType::kCRC32C:
627 case XrdClHttp::ChecksumType::kSHA1:
629 case XrdClHttp::ChecksumType::kSHA256:
631 case XrdClHttp::ChecksumType::kAll: {
634 value < static_cast<int>(XrdClHttp::ChecksumType::kAll);
636 if (!result.empty()) result +=
',';
648 bool HeaderParser::validHeaderByte(
unsigned char c)
650 const static uint64_t mask_lower = 0 |
651 uint64_t((1<<10)-1) <<
'0' |
657 uint64_t(1) <<
'\'' |
663 const static uint64_t mask_upper = 0 |
664 uint64_t((1<<26)-1) << (
'a'-64) |
665 uint64_t((1<<26)-1) << (
'A'-64) |
666 uint64_t(1) << (
'^'-64) |
667 uint64_t(1) << (
'_'-64) |
668 uint64_t(1) << (
'`'-64) |
669 uint64_t(1) << (
'|'-64) |
670 uint64_t(1) << (
'~'-64);
672 if (c >= 128)
return false;
673 if (c >= 64)
return (uint64_t(1)<<(c-64)) & mask_upper;
674 return (uint64_t(1) << c) & mask_lower;
680 const static int toLower =
'a' -
'A';
681 for (
size_t idx=0; idx<headerName.size(); idx++) {
682 char c = headerName[idx];
683 if (!validHeaderByte(c)) {
686 if (upper &&
'a' <= c && c <=
'z') {
688 }
else if (!upper &&
'A' <= c && c <=
'Z') {
698 m_max_pending_ops(max_pending_ops)
701 auto result = pipe(filedes);
703 throw std::system_error(errno, std::generic_category(),
704 "failed to create HTTP worker pipe");
706 if (fcntl(filedes[0], F_SETFL, O_NONBLOCK | O_CLOEXEC) == -1 || fcntl(filedes[1], F_SETFL, O_NONBLOCK | O_CLOEXEC) == -1) {
707 const int error = errno;
710 throw std::system_error(error, std::generic_category(),
711 "failed to configure HTTP worker pipe");
713 m_read_fd = filedes[0];
714 m_write_fd = filedes[1];
719 bool EnableCurlHeaderDump() {
728 int DumpHeader(
CURL *handle, curl_infotype type,
char *data,
size_t size,
void *clientp) {
730 auto *logger =
static_cast<XrdCl::Log *
>(clientp);
731 if (!logger || !data || size == 0) {
735 const char *direction =
nullptr;
737 case CURLINFO_HEADER_OUT:
740 case CURLINFO_HEADER_IN:
747 const std::string redacted =
obfuscateAuth(std::string(data, size));
748 logger->Debug(
kLogXrdClHttp,
"%s %s", direction, redacted.c_str());
757 for (
size_t idx = 0; idx < input_view.size(); idx++) {
758 if (!isspace(view[view.size() - 1 - idx])) {
759 return view.substr(0, view.size() - idx);
767 for (
size_t idx = 0; idx < input_view.size(); idx++) {
768 if (!isspace(input_view[idx])) {
769 return input_view.substr(idx);
777 curl_easy_setopt(curl, CURLOPT_USERAGENT,
"xrdcl-http/" XrdVERSION);
778 curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, DumpHeader);
781 curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
785 if (!env->GetString(
"HttpCertFile", ca_file) || ca_file.empty()) {
786 char *x509_ca_file = getenv(
"X509_CERT_FILE");
788 ca_file = std::string(x509_ca_file);
791 if (!ca_file.empty()) {
792 curl_easy_setopt(curl, CURLOPT_CAINFO, ca_file.c_str());
795 if (!env->GetString(
"HttpCertDir", ca_dir) || ca_dir.empty()) {
796 char *x509_ca_dir = getenv(
"X509_CERT_DIR");
798 ca_dir = std::string(x509_ca_dir);
801 if (!ca_dir.empty()) {
802 curl_easy_setopt(curl, CURLOPT_CAPATH, ca_dir.c_str());
805 curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 32*1024);
810 auto result = curl_easy_init();
811 if (result ==
nullptr) {
822 if (m_handles.size()) {
823 auto result = m_handles.back();
824 m_handles.pop_back();
833 m_handles.push_back(curl);
839 std::unique_lock<std::mutex> lk(m_mutex);
840 auto now = std::chrono::steady_clock::now();
843 for (
auto &op : m_ops) {
844 if (!op->IsPaused())
continue;
846 if (op->TransferStalled(0, now)) {
847 op->ContinueHandle();
851 std::vector<decltype(m_ops)::value_type> expired_ops;
852 unsigned expired_count = 0;
853 auto it = std::remove_if(m_ops.begin(), m_ops.end(),
854 [&](
const std::shared_ptr<CurlOperation> &handler) {
855 auto expired = handler->GetOperationExpiry() < now;
857 expired_ops.push_back(handler);
862 m_ops.erase(it, m_ops.end());
867 unsigned bytes_to_read = expired_count;
868 while (bytes_to_read > 0) {
869 size_t chunk = std::min<size_t>(
sizeof(throwaway), bytes_to_read);
870 ssize_t n =
read(m_read_fd, throwaway, chunk);
873 }
else if (n == -1) {
874 if (errno == EINTR) {
894 for (
auto &handler : expired_ops) {
900 HandlerQueue::Produce(std::shared_ptr<CurlOperation> handler)
902 auto handler_expiry = handler->GetOperationExpiry();
903 std::unique_lock<std::mutex> lk{m_mutex};
904 m_producer_cv.wait_until(lk,
906 [&]{
return m_ops.size() < m_max_pending_ops;}
908 if (std::chrono::steady_clock::now() > handler_expiry) {
911 m_ops_rejected.fetch_add(1, std::memory_order_relaxed);
915 m_ops.push_back(handler);
918 auto result =
write(m_write_fd, ready, 1);
920 if (errno == EINTR) {
922 }
else if (errno == EAGAIN || errno == EWOULDBLOCK) {
927 throw std::system_error(errno, std::generic_category(),
928 "failed to notify HTTP worker");
934 m_consumer_cv.notify_one();
935 m_ops_produced.fetch_add(1, std::memory_order_relaxed);
938 std::shared_ptr<CurlOperation>
939 HandlerQueue::Consume(std::chrono::steady_clock::duration dur)
941 std::unique_lock<std::mutex> lk(m_mutex);
942 m_consumer_cv.wait_for(lk, dur, [&]{
return m_ops.size() > 0 || m_shutdown;});
943 if (m_shutdown || m_ops.empty()) {
947 std::shared_ptr<CurlOperation> result = m_ops.front();
952 auto result =
read(m_read_fd, ready, 1);
954 if (errno == EINTR) {
956 }
else if (errno == EAGAIN || errno == EWOULDBLOCK) {
961 throw std::system_error(errno, std::generic_category(),
962 "failed to consume HTTP worker notification");
968 m_producer_cv.notify_one();
969 m_ops_consumed.fetch_add(1, std::memory_order_relaxed);
975 HandlerQueue::GetMonitoringJson()
977 auto consumed = m_ops_consumed.load(std::memory_order_relaxed);
978 auto produced = m_ops_produced.load(std::memory_order_relaxed);
980 "\"produced\":" + std::to_string(produced) +
","
981 "\"consumed\":" + std::to_string(consumed) +
","
982 "\"pending\":" + std::to_string(produced - consumed) +
","
983 "\"rejected\":" + std::to_string(m_ops_rejected.load(std::memory_order_relaxed)) +
987 std::shared_ptr<CurlOperation>
988 HandlerQueue::TryConsume()
990 std::unique_lock<std::mutex> lk(m_mutex);
991 if (m_ops.size() == 0) {
992 std::shared_ptr<CurlOperation> result;
996 std::shared_ptr<CurlOperation> result = m_ops.front();
1001 auto result =
read(m_read_fd, ready, 1);
1003 if (errno == EINTR) {
1005 }
else if (errno == EAGAIN || errno == EWOULDBLOCK) {
1010 throw std::system_error(errno, std::generic_category(),
1011 "failed to consume HTTP worker notification");
1017 m_producer_cv.notify_one();
1018 m_ops_consumed.fetch_add(1, std::memory_order_relaxed);
1024 HandlerQueue::Shutdown()
1026 std::unique_lock lock(m_mutex);
1028 m_consumer_cv.notify_all();
1032 HandlerQueue::ReleaseHandles()
1034 for (
auto handle : m_handles) {
1035 curl_easy_cleanup(handle);
1046 std::unique_lock lk(m_worker_stats_mutex);
1047 m_stats_offset = m_workers_last_completed_cycle.size();
1048 m_workers_last_completed_cycle.push_back(&m_last_completed_cycle);
1049 m_workers_oldest_op.push_back(&m_oldest_op);
1052 if ((pipe(pipeInfo) == -1) || (fcntl(pipeInfo[0], F_SETFD, FD_CLOEXEC)) || (fcntl(pipeInfo[1], F_SETFD, FD_CLOEXEC))) {
1053 throw std::runtime_error(
"Failed to create shutdown monitoring pipe for curl worker");
1055 m_shutdown_pipe_r = pipeInfo[0];
1056 m_shutdown_pipe_w = pipeInfo[1];
1060 env->GetString(
"HttpClientCertFile", m_x509_client_cert_file);
1061 env->GetString(
"HttpClientKeyFile", m_x509_client_key_file);
1066 return std::make_tuple(m_x509_client_cert_file, m_x509_client_key_file);
1072 auto now = std::chrono::system_clock::now().time_since_epoch().count();
1073 auto oldest_op = now;
1074 auto oldest_cycle = now;
1076 std::unique_lock lk(m_worker_stats_mutex);
1077 for (
const auto &entry : m_workers_last_completed_cycle) {
1078 if (!entry) {
continue;}
1079 auto cycle = entry->load(std::memory_order_relaxed);
1080 if (cycle < oldest_cycle) oldest_cycle = cycle;
1082 for (
const auto &entry : m_workers_oldest_op) {
1083 if (!entry) {
continue;}
1084 auto op = entry->load(std::memory_order_relaxed);
1085 if (op < oldest_op) oldest_op = op;
1088 auto oldest_op_dbl = std::chrono::duration<double>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(oldest_op)).time_since_epoch()).count();
1089 auto oldest_cycle_dbl = std::chrono::duration<double>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(oldest_cycle)).time_since_epoch()).count();
1090 std::string retval =
"{"
1091 "\"oldest_op\":" + std::to_string(oldest_op_dbl) +
","
1092 "\"oldest_cycle\":" + std::to_string(oldest_cycle_dbl) +
","
1095 for (
size_t verb_idx = 0; verb_idx < static_cast<int>(XrdClHttp::CurlOperation::HttpVerb::Count); verb_idx++) {
1097 for (
size_t op_idx = 0; op_idx < 402; op_idx++) {
1098 if (op_idx == 401)
continue;
1100 auto &op_stats = m_ops[verb_idx][op_idx];
1101 auto duration = op_stats.m_duration.load(std::memory_order_relaxed);
1102 if (duration == 0)
continue;
1104 std::string prefix =
"http_" + verb_str +
"_" + ((op_idx == 402) ?
"invalid" : std::to_string(200 + op_idx)) +
"_";
1106 auto duration_dbl = std::chrono::duration<double>(std::chrono::steady_clock::duration(duration)).count();
1107 retval +=
"\"" + prefix +
"duration\":" + std::to_string(duration_dbl) +
",";
1109 duration = op_stats.m_pause_duration.load(std::memory_order_relaxed);
1111 duration_dbl = std::chrono::duration<double>(std::chrono::steady_clock::duration(duration)).count();
1112 retval +=
"\"" + prefix +
"pause_duration\":" + std::to_string(duration_dbl) +
",";
1115 auto count = op_stats.m_bytes.load(std::memory_order_relaxed);
1116 if (count) retval +=
"\"" + prefix +
"bytes\":" + std::to_string(count) +
",";
1117 count = op_stats.m_error.load(std::memory_order_relaxed);
1118 if (count) retval +=
"\"" + prefix +
"error\":" + std::to_string(count) +
",";
1119 count = op_stats.m_finished.load(std::memory_order_relaxed);
1120 if (count) retval +=
"\"" + prefix +
"finished\":" + std::to_string(count) +
",";
1121 count = op_stats.m_client_timeout.load(std::memory_order_relaxed);
1122 if (count) retval +=
"\"" + prefix +
"client_timeout\":" + std::to_string(count) +
",";
1123 count = op_stats.m_server_timeout.load(std::memory_order_relaxed);
1124 if (count) retval +=
"\"" + prefix +
"server_timeout\":" + std::to_string(count) +
",";
1127 auto &op_stats = m_ops[verb_idx][401];
1128 auto duration = op_stats.m_duration.load(std::memory_order_relaxed);
1129 if (duration == 0)
continue;
1131 std::string prefix =
"http_" + verb_str +
"_";
1133 auto duration_dbl = std::chrono::duration<double>(std::chrono::steady_clock::duration(duration)).count();
1134 retval +=
"\"" + prefix +
"preheader_duration\":" + std::to_string(duration_dbl) +
",";
1136 auto count = op_stats.m_started.load(std::memory_order_relaxed);
1137 if (count) retval +=
"\"" + prefix +
"started\":" + std::to_string(count) +
",";
1138 count = op_stats.m_error.load(std::memory_order_relaxed);
1139 if (count) retval +=
"\"" + prefix +
"preheader_error\":" + std::to_string(count) +
",";
1140 count = op_stats.m_finished.load(std::memory_order_relaxed);
1141 if (count) retval +=
"\"" + prefix +
"preheader_finished\":" + std::to_string(count) +
",";
1142 count = op_stats.m_server_timeout.load(std::memory_order_relaxed);
1143 if (count) retval +=
"\"" + prefix +
"preheader_timeout\":" + std::to_string(count) +
",";
1144 count = op_stats.m_conncall_timeout.load(std::memory_order_relaxed);
1145 if (count) retval +=
"\"" + prefix +
"conncall_timeout\":" + std::to_string(count) +
",";
1150 "\"conncall_error\":" + std::to_string(m_conncall_errors.load(std::memory_order_relaxed)) +
","
1151 "\"conncall_started\":" + std::to_string(m_conncall_req.load(std::memory_order_relaxed)) +
","
1152 "\"conncall_success\":" + std::to_string(m_conncall_success.load(std::memory_order_relaxed)) +
","
1153 "\"conncall_timeout\":" + std::to_string(m_conncall_timeout.load(std::memory_order_relaxed)) +
1166 if (sc < 0 || kind == OpKind::Start || sc == 100) {
1168 }
else if (sc < 200 || sc >= 600) {
1173 auto [bytes, pre_headers, post_headers, pause_duration] = op.
StatisticsReset();
1174 auto &op_stats = m_ops[
static_cast<int>(op.
GetVerb())][sc];
1175 op_stats.m_bytes.fetch_add(bytes, std::memory_order_relaxed);
1176 op_stats.m_duration.fetch_add((sc == 401) ? pre_headers.count() : post_headers.count(), std::memory_order_relaxed);
1177 op_stats.m_pause_duration.fetch_add(pause_duration.count(), std::memory_order_relaxed);
1178 if (pre_headers != std::chrono::steady_clock::duration::zero() && sc != 401) {
1179 auto &old_stats = m_ops[
static_cast<int>(op.
GetVerb())][401];
1180 old_stats.m_duration.fetch_add(pre_headers.count(), std::memory_order_relaxed);
1183 case OpKind::ConncallTimeout:
1184 op_stats.m_conncall_timeout.fetch_add(1, std::memory_order_relaxed);
1186 case OpKind::ClientTimeout:
1187 op_stats.m_client_timeout.fetch_add(1, std::memory_order_relaxed);
1190 op_stats.m_error.fetch_add(1, std::memory_order_relaxed);
1192 case OpKind::Finish:
1193 op_stats.m_finished.fetch_add(1, std::memory_order_relaxed);
1196 op_stats.m_started.fetch_add(1, std::memory_order_relaxed);
1198 case OpKind::ServerTimeout:
1199 op_stats.m_server_timeout.fetch_add(1, std::memory_order_relaxed);
1201 case OpKind::Update:
1210 std::unique_lock lock(m_workers_mutex);
1211 m_workers.emplace_back(std::move(
self));
1212 m_self_tid = std::move(tid);
1214 std::unique_lock lock(m_start_lock);
1215 m_start_complete =
true;
1216 m_start_complete_cv.notify_one();
1223 std::unique_lock lock(myself->m_start_lock);
1224 myself->m_start_complete_cv.wait(lock, [&]{
return myself->m_start_complete;});
1231 std::unique_lock lock(m_workers_mutex);
1232 auto iter = std::remove_if(m_workers.begin(), m_workers.end(), [&](std::unique_ptr<XrdClHttp::CurlWorker> &worker){return worker.get() == myself;});
1233 m_workers.erase(iter);
1240 int max_pending = 50;
1243 auto &queue = *m_queue.get();
1246 CURLM *multi_handle = curl_multi_init();
1247 if (multi_handle ==
nullptr) {
1248 throw std::runtime_error(
"Failed to create curl multi-handle");
1251 int running_handles = 0;
1252 time_t last_maintenance = time(NULL);
1253 CURLMcode mres = CURLM_OK;
1257 std::unordered_map<int, WaitingForBroker> broker_reqs;
1258 std::vector<struct curl_waitfd> waitfds;
1262 auto release_handle = [&](
const std::shared_ptr<CurlOperation> &op,
CURL *handle) {
1263 if (!handle)
return;
1264 curl_multi_remove_handle(multi_handle, handle);
1265 if (op->GetCurlHandle()) op->ReleaseHandle();
1266 curl_easy_cleanup(handle);
1268 auto remove_op = [&](
CURL *handle) {
1269 auto iter = m_op_map.find(handle);
1270 if (iter == m_op_map.end())
return;
1271 const auto &[op, started_at] = iter->second;
1272 release_handle(op, handle);
1273 m_op_map.erase(iter);
1274 running_handles -= 1;
1275 for (
auto req = broker_reqs.begin(); req != broker_reqs.end();) {
1276 if (req->second.curl == handle) {
1277 req = broker_reqs.erase(req);
1283 auto start_options = [&](
CURL *parent_handle,
const std::shared_ptr<CurlOperation> &parent_op,
1284 const std::string &target) {
1285 std::shared_ptr<CurlOptionsOp> options_op;
1286 CURL *options_handle =
nullptr;
1288 std::string modified_url;
1289 options_op = std::make_shared<CurlOptionsOp>(parent_handle, parent_op,
1291 m_logger, parent_op->GetConnCalloutFunc());
1292 options_handle = queue.GetHandle();
1293 if (!options_handle || !options_op->Setup(options_handle, *
this)) {
1294 throw std::runtime_error(
"Failed to setup the curl handle for OPTIONS");
1300 "Failed to setup the curl handle for the OPTIONS operation");
1301 release_handle(options_op, options_handle);
1304 "Failed to setup the curl handle for the OPTIONS operation");
1308 m_op_map[options_handle] = {options_op, std::chrono::system_clock::now()};
1309 OpRecord(*options_op, OpKind::Start);
1310 running_handles += 1;
1311 auto options_res = curl_multi_add_handle(multi_handle, options_handle);
1312 if (options_res == CURLM_OK)
return true;
1314 "Unable to add OPTIONS operation to the curl multi-handle");
1317 "Unable to add OPTIONS operation to the curl multi-handle");
1319 remove_op(options_handle);
1322 auto reactivate_parent = [&](
const std::shared_ptr<CurlOptionsOp> &options_op) {
1323 auto parent_op = options_op->GetOperation();
1324 auto parent_handle = options_op->GetParentCurlHandle();
1325 if (parent_op->IsDone()) {
1326 remove_op(parent_handle);
1331 if (parent_op->IsRedirect()) {
1333 auto action = parent_op->Redirect(target);
1334 if (action == CurlOperation::RedirectAction::Fail) {
1336 remove_op(parent_handle);
1339 if (action == CurlOperation::RedirectAction::ReinvokeAfterAllow) {
1340 if (start_options(parent_handle, parent_op, target))
return true;
1341 remove_op(parent_handle);
1345 OpRecord(*parent_op, OpKind::Start);
1346 auto callout_socket = parent_op->WaitSocket();
1347 if (callout_socket >= 0) {
1348 broker_reqs[callout_socket] = {parent_handle, time(
nullptr) + 20};
1349 m_conncall_req.fetch_add(1, std::memory_order_relaxed);
1352 auto parent_res = curl_multi_add_handle(multi_handle, parent_handle);
1353 if (parent_res == CURLM_OK)
return true;
1355 "Unable to re-add the parent operation to the curl multi-handle: %s",
1356 curl_multi_strerror(parent_res));
1358 "Unable to re-add the parent operation to the curl multi-handle");
1360 remove_op(parent_handle);
1364 bool want_shutdown =
false;
1365 while (!want_shutdown) {
1366 m_last_completed_cycle.store(std::chrono::system_clock::now().time_since_epoch().count());
1367 auto oldest_op = std::chrono::system_clock::now();
1368 for (
const auto &[handle, entry] : m_op_map) {
1369 const auto &[op, started_at] = entry;
1370 OpRecord(*op, OpKind::Update);
1371 if (started_at < oldest_op) {
1372 oldest_op = started_at;
1375 m_oldest_op.store(oldest_op.time_since_epoch().count());
1379 auto op = m_continue_queue->TryConsume();
1386 m_logger->
Debug(
kLogXrdClHttp,
"Ignoring continuation of operation that has already completed");
1389 m_logger->
Debug(
kLogXrdClHttp,
"Continuing the curl handle from op %p on thread %d", op.get(), getthreadid());
1390 auto curl = op->GetCurlHandle();
1391 if (!op->ContinueHandle()) {
1392 op->Fail(
XrdCl::errInternal, 0,
"Failed to continue the curl handle for the operation");
1397 auto iter = m_op_map.find(curl);
1398 if (iter != m_op_map.end()) {
1399 auto &[operation, started_at] = iter->second;
1400 started_at = std::chrono::system_clock::now();
1405 while (running_handles <
static_cast<int>(m_max_ops)) {
1406 auto op = running_handles == 0 ? queue.Consume(std::chrono::seconds(1)) : queue.TryConsume();
1410 auto curl = queue.GetHandle();
1411 if (curl ==
nullptr) {
1417 auto rv = op->Setup(curl, *
this);
1420 op->Fail(
XrdCl::errInternal, ENOMEM,
"Failed to setup the curl handle for the operation");
1421 release_handle(op, curl);
1424 if (!op->FinishSetup(curl)) {
1426 op->Fail(
XrdCl::errInternal, ENOMEM,
"Failed to finish setup of the curl handle for the operation");
1427 release_handle(op, curl);
1432 op->Fail(
XrdCl::errInternal, ENOMEM,
"Failed to setup the curl handle for the operation");
1433 release_handle(op, curl);
1436 op->SetContinueQueue(m_continue_queue);
1439 op->ReleaseHandle();
1440 queue.RecycleHandle(curl);
1443 m_op_map[curl] = {op, std::chrono::system_clock::now()};
1444 running_handles += 1;
1448 if (op->RequiresOptions()) {
1449 if (!start_options(curl, op, op->GetUrl())) {
1454 OpRecord(*op, OpKind::Start);
1455 auto add_res = curl_multi_add_handle(multi_handle, curl);
1456 if (add_res != CURLM_OK) {
1458 op->Fail(
XrdCl::errInternal, add_res,
"Unable to add operation to the curl multi-handle");
1464 m_logger->
Debug(
kLogXrdClHttp,
"Added request for URL %s to worker thread for processing", op->GetUrl().c_str());
1469 time_t now = time(NULL);
1470 time_t next_maintenance = last_maintenance + m_maintenance_period.load(std::memory_order_relaxed);
1471 if (now >= next_maintenance) {
1473 m_continue_queue->Expire();
1475 getthreadid(), running_handles);
1476 last_maintenance = now;
1479 std::vector<std::pair<int, CURL *>> expired_ops;
1480 for (
const auto &[fd, request] : broker_reqs) {
1481 if (request.expiry < now) {
1482 expired_ops.emplace_back(fd, request.curl);
1485 for (
const auto &[fd, handle] : expired_ops) {
1486 auto iter = m_op_map.find(handle);
1487 if (iter == m_op_map.end()) {
1488 m_logger->
Warning(
kLogXrdClHttp,
"Found an expired curl handle with no corresponding operation!");
1490 auto [op, started_at] = iter->second;
1492 OpRecord(*op, OpKind::ConncallTimeout);
1493 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1494 reactivate_parent(options_op);
1497 broker_reqs.erase(fd);
1498 m_conncall_timeout.fetch_add(1, std::memory_order_relaxed);
1506 waitfds.resize(3 + broker_reqs.size());
1508 waitfds[0].fd = queue.PollFD();
1509 waitfds[0].events = CURL_WAIT_POLLIN;
1510 waitfds[0].revents = 0;
1511 waitfds[1].fd = m_continue_queue->PollFD();
1512 waitfds[1].events = CURL_WAIT_POLLIN;
1513 waitfds[1].revents = 0;
1514 waitfds[2].fd = m_shutdown_pipe_r;
1515 waitfds[2].revents = 0;
1516 waitfds[2].events = CURL_WAIT_POLLIN | CURL_WAIT_POLLPRI;
1519 for (
const auto &[fd, request] : broker_reqs) {
1520 waitfds[idx].fd = fd;
1521 waitfds[idx].events = CURL_WAIT_POLLIN|CURL_WAIT_POLLPRI;
1522 waitfds[idx].revents = 0;
1527 curl_multi_timeout(multi_handle, &timeo);
1531 if (running_handles && timeo == -1) {
1536 mres = curl_multi_wait(multi_handle, &waitfds[0], waitfds.size(), 50,
nullptr);
1542 mres = curl_multi_wait(multi_handle, &waitfds[0], waitfds.size(), 50,
nullptr);
1544 if (mres != CURLM_OK) {
1549 for (
const auto &entry : waitfds) {
1551 if (waitfds[0].fd == entry.fd || waitfds[1].fd == entry.fd) {
1555 if ((waitfds[2].fd == entry.fd) && entry.revents) {
1556 want_shutdown =
true;
1559 if ((entry.revents & CURL_WAIT_POLLIN) != CURL_WAIT_POLLIN) {
1562 auto request = broker_reqs.find(entry.fd);
1563 if (request == broker_reqs.end())
continue;
1564 auto handle = request->second.curl;
1565 auto iter = m_op_map.find(handle);
1566 if (iter == m_op_map.end()) {
1567 m_logger->
Warning(
kLogXrdClHttp,
"Internal error: broker responded on FD %d but no corresponding curl operation", entry.fd);
1568 broker_reqs.erase(entry.fd);
1569 m_conncall_errors.fetch_add(1, std::memory_order_relaxed);
1573 auto [op, started_at] = iter->second;
1574 auto result = op->WaitSocketCallback(err);
1579 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1580 reactivate_parent(options_op);
1582 broker_reqs.erase(entry.fd);
1583 m_conncall_errors.fetch_add(1, std::memory_order_relaxed);
1585 broker_reqs.erase(entry.fd);
1586 auto add_res = curl_multi_add_handle(multi_handle, handle);
1587 if (add_res != CURLM_OK) {
1589 "Unable to add operation to the curl multi-handle after the broker callback");
1591 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1592 reactivate_parent(options_op);
1594 m_conncall_errors.fetch_add(1, std::memory_order_relaxed);
1597 m_conncall_success.fetch_add(1, std::memory_order_relaxed);
1603 mres = curl_multi_perform(multi_handle, &still_running);
1604 if (mres == CURLM_CALL_MULTI_PERFORM) {
1607 }
else if (mres != CURLM_OK) {
1615 msg = curl_multi_info_read(multi_handle, &msgq);
1616 if (msg && (msg->msg == CURLMSG_DONE)) {
1617 if (!msg->easy_handle) {
1619 mres = CURLM_BAD_EASY_HANDLE;
1622 CURL *
const easy_handle = msg->easy_handle;
1623 auto iter = m_op_map.find(easy_handle);
1624 if (iter == m_op_map.end()) {
1625 m_logger->
Error(
kLogXrdClHttp,
"Logic error: got a callback for an entry that doesn't exist");
1626 mres = CURLM_BAD_EASY_HANDLE;
1629 auto [op, started_at] = iter->second;
1630 auto res = msg->data.result;
1633 curl_multi_remove_handle(multi_handle, easy_handle);
1634 bool keep_handle =
false;
1635 bool waiting_on_callout =
false;
1636 bool options_pending =
false;
1637 if (res == CURLE_OK) {
1638 auto sc = op->GetStatusCode();
1639 OpRecord(*op, OpKind::Finish);
1642 op->Fail(code, number, op->GetStatusMessage());
1643 op->ReleaseHandle();
1647 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1648 reactivate_parent(options_op);
1650 queue.RecycleHandle(easy_handle);
1655 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op)) {
1656 options_op->Success();
1657 options_op->ReleaseHandle();
1658 if (!options_op->GetOperation()->IsDone()) {
1659 options_op->GetOperation()->OptionsDone();
1661 reactivate_parent(options_op);
1662 queue.RecycleHandle(easy_handle);
1664 if (op->IsRedirect()) {
1666 switch (op->Redirect(target)) {
1667 case CurlOperation::RedirectAction::Fail:
1668 keep_handle =
false;
1670 case CurlOperation::RedirectAction::Reinvoke:
1672 OpRecord(*op, OpKind::Start);
1674 case CurlOperation::RedirectAction::ReinvokeAfterAllow:
1681 if (!start_options(easy_handle, op, target)) {
1682 keep_handle =
false;
1685 m_logger->
Debug(
kLogXrdClHttp,
"Invoking the OPTIONS operation before redirect to %s", target.c_str());
1688 options_pending =
true;
1692 int callout_socket = op->WaitSocket();
1693 if ((waiting_on_callout = keep_handle && !options_pending && callout_socket >= 0)) {
1694 auto expiry = time(
nullptr) + 20;
1695 m_logger->
Debug(
kLogXrdClHttp,
"Creating a callout wait request on socket %d", callout_socket);
1696 broker_reqs[callout_socket] = {easy_handle, expiry};
1697 m_conncall_req.fetch_add(1, std::memory_order_relaxed);
1701 if (!waiting_on_callout && !options_pending) {
1702 auto redirect_res = curl_multi_add_handle(multi_handle, easy_handle);
1703 if (redirect_res != CURLM_OK) {
1705 "Unable to add redirected operation to the curl multi-handle");
1707 op->ReleaseHandle();
1708 queue.RecycleHandle(easy_handle);
1709 keep_handle =
false;
1713 if (!op->IsDone()) {
1717 op->ReleaseHandle();
1719 queue.RecycleHandle(easy_handle);
1725 auto next_res = curl_multi_add_handle(multi_handle, easy_handle);
1726 if (next_res == CURLM_OK) {
1728 OpRecord(*op, OpKind::Start);
1731 "Unable to add the next operation request to the curl multi-handle");
1733 op->ReleaseHandle();
1734 queue.RecycleHandle(easy_handle);
1740 }
else if (res == CURLE_COULDNT_CONNECT && op->UseConnectionCallout() && !op->GetTriedBoker()) {
1744 op->SetTriedBoker();
1746 int wait_socket = -1;
1747 if (!op->StartConnectionCallout(err) || (wait_socket=op->WaitSocket()) == -1) {
1748 m_logger->
Error(
kLogXrdClHttp,
"Failed to start broker-based connection: %s", err.c_str());
1752 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1753 reactivate_parent(options_op);
1754 op->ReleaseHandle();
1755 keep_handle =
false;
1757 curl_multi_remove_handle(multi_handle, easy_handle);
1758 auto expiry = time(
nullptr) + 20;
1759 m_logger->
Debug(
kLogXrdClHttp,
"Curl operation requires a new TCP socket; waiting for callout to respond on socket %d", wait_socket);
1760 broker_reqs[wait_socket] = {easy_handle, expiry};
1761 m_conncall_req.fetch_add(1, std::memory_order_relaxed);
1764 if (res == CURLE_ABORTED_BY_CALLBACK || res == CURLE_WRITE_ERROR) {
1767 switch (op->GetError()) {
1768 case CurlOperation::OpError::ErrHeaderTimeout:
1769 #ifdef HAVE_XPROTOCOL_TIMEREXPIRED
1776 case CurlOperation::OpError::ErrCallback: {
1777 auto [ecode,
emsg] = op->GetCallbackError();
1782 case CurlOperation::OpError::ErrOperationTimeout:
1784 OpRecord(*op, op->IsPaused() ? OpKind::ClientTimeout : OpKind::ServerTimeout);
1786 case CurlOperation::OpError::ErrTransferSlow:
1788 OpRecord(*op, OpKind::ServerTimeout);
1790 case CurlOperation::OpError::ErrTransferClientStall:
1792 OpRecord(*op, OpKind::ClientTimeout);
1794 case CurlOperation::OpError::ErrTransferStall:
1796 OpRecord(*op, OpKind::ServerTimeout);
1798 case CurlOperation::OpError::ErrNone:
1799 op->Fail(
XrdCl::errInternal, 0,
"Operation was aborted without recording an abort reason");
1803 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1804 reactivate_parent(options_op);
1807 const auto curl_err = op->GetCurlErrorMessage();
1808 const char *curl_easy_err = curl_easy_strerror(res);
1809 const std::string fail_err = !curl_err.empty() ? curl_err : curl_easy_err;
1810 m_logger->
Debug(
kLogXrdClHttp,
"Curl generated an error: %s (%d)", fail_err.c_str(), res);
1811 op->Fail(code, number, fail_err);
1813 if (
auto options_op = std::dynamic_pointer_cast<CurlOptionsOp>(op))
1814 reactivate_parent(options_op);
1816 op->ReleaseHandle();
1819 curl_multi_remove_handle(multi_handle, easy_handle);
1820 if (res != CURLE_OK) {
1821 curl_easy_cleanup(easy_handle);
1823 for (
auto req = broker_reqs.begin(); req != broker_reqs.end();) {
1824 if (req->second.curl == easy_handle) {
1825 m_logger->
Warning(
kLogXrdClHttp,
"Curl handle finished while a broker operation was outstanding");
1826 m_conncall_errors.fetch_add(1, std::memory_order_relaxed);
1827 req = broker_reqs.erase(req);
1832 m_op_map.erase(easy_handle);
1833 running_handles -= 1;
1837 if (mres != CURLM_OK)
break;
1840 for (
const auto &[handle, entry] : m_op_map) {
1841 const auto &[op, started_at] = entry;
1842 if (!op->IsDone()) {
1843 const auto err_num = mres == CURLM_OK ? ECANCELED :
static_cast<int>(mres);
1844 const std::string err_msg = mres == CURLM_OK
1845 ?
"Curl worker shut down before the operation completed"
1846 : curl_multi_strerror(mres);
1850 release_handle(op, handle);
1854 m_queue->ReleaseHandles();
1855 curl_multi_cleanup(multi_handle);
1859 CurlWorker::Shutdown()
1861 m_queue->Shutdown();
1862 if (m_shutdown_pipe_w == -1) {
1866 close(m_shutdown_pipe_w);
1867 m_shutdown_pipe_w = -1;
1873 std::unique_lock lk(m_worker_stats_mutex);
1874 m_workers_last_completed_cycle[m_stats_offset] =
nullptr;
1875 m_workers_oldest_op[m_stats_offset] =
nullptr;
1881 CurlWorker::ShutdownAll()
1883 std::unique_lock lock(m_workers_mutex);
1884 for (
auto &worker : m_workers) {
1889 CurlWorker::initcontrol::initcontrol()
1891 curl_global_init(CURL_GLOBAL_DEFAULT);
1894 CurlWorker::initcontrol::~initcontrol()
1897 curl_global_cleanup();
std::pair< uint16_t, uint32_t > CurlCodeConvert(CURLcode res)
std::string obfuscateAuth(const std::string &input)
ssize_t read(int fildes, void *buf, size_t nbyte)
void getline(uchar *buff, int blen)
int emsg(int rc, char *msg)
int Set(const char *csName)
bool Set(ChecksumType ctype, const std::array< unsigned char, g_max_checksum_length > &value)
int GetStatusCode() const
static const std::string GetVerbString(HttpVerb)
virtual HttpVerb GetVerb() const =0
static void CleanupDnsCache()
std::tuple< uint64_t, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration > StatisticsReset()
XrdClHttp::HttpVerb HttpVerb
std::tuple< std::string, std::string > ClientX509CertKeyFile() const
static void RunStatic(CurlWorker *myself)
void Start(std::unique_ptr< XrdClHttp::CurlWorker > self, std::thread tid)
static std::string GetMonitoringJson()
HandlerQueue(unsigned max_pending_ops)
void RecycleHandle(CURL *)
static std::string_view GetUrlKey(const std::string &url, std::string &modified_url)
static Log * GetLog()
Get default log.
static Env * GetEnv()
Get default client environment.
bool GetInt(const std::string &key, int &value)
@ DumpMsg
print details of the request and responses
void Error(uint64_t topic, const char *format,...)
Report an error.
void Warning(uint64_t topic, const char *format,...)
Report a warning.
void Debug(uint64_t topic, const char *format,...)
Print a debug message.
std::string GetURL() const
Get the URL.
const ParamsMap & GetParams() const
Get the URL params.
static void splitString(Container &result, const std::string &input, const std::string &delimiter)
Split a string.
static void Trim(std::string &str)
Trim a string.
std::pair< uint16_t, uint32_t > HTTPStatusConvert(unsigned status)
size_t GetChecksumLength(ChecksumType ctype)
void InjectBearerToken(const XrdCl::URL &url, std::vector< std::pair< std::string, std::string >> &headers, XrdCl::Log *logger=nullptr)
CURL * GetHandle(bool verbose)
bool HTTPStatusIsError(unsigned status)
bool ShouldUseBearerToken(const std::string &protocols, bool hasX509Credential, bool hasBearerToken)
std::string_view ltrim_view(const std::string_view &input_view)
std::string GetBearerToken(XrdCl::Log *logger=nullptr)
void ConfigureHandle(CURL *curl, bool verbose)
std::string_view trim_view(const std::string_view &input_view)
const uint16_t errUnknown
Unknown error.
const uint16_t errInvalidAddr
const uint16_t errRedirectLimit
const uint16_t errErrorResponse
const uint16_t errTlsError
const uint16_t errOperationExpired
const uint16_t errLoginFailed
const uint16_t errDataError
data is corrupted
const uint16_t errInternal
Internal error.
const uint16_t errInvalidArgs
const uint16_t errConnectionError
const uint16_t errNotSupported
const uint16_t errSocketError
const uint16_t errCorruptedHeader
const uint16_t errNone
No error.
const uint64_t kLogXrdClHttp