#include <XrdClHttpOps.hh>

Inheritance diagram for XrdClHttp::CurlOperation:

Collaboration diagram for XrdClHttp::CurlOperation:

Public Types
using	HeaderList = std::vector< std::pair< std::string, std::string > >

using	HttpVerb = XrdClHttp::HttpVerb

enum	OpError { ErrNone , ErrHeaderTimeout , ErrCallback , ErrOperationTimeout , ErrTransferClientStall , ErrTransferStall , ErrTransferSlow }

enum class	RedirectAction { Fail , Reinvoke , ReinvokeAfterAllow }

Public Member Functions
	CurlOperation (const CurlOperation &)=delete

	CurlOperation (XrdCl::ResponseHandler handler, const std::string &url, std::chrono::steady_clock::time_point expiry, XrdCl::Log log, CreateConnCalloutType, HeaderCallout *header_callout)

	CurlOperation (XrdCl::ResponseHandler handler, const std::string &url, struct timespec timeout, XrdCl::Log log, CreateConnCalloutType, HeaderCallout *header_callout)

virtual	~CurlOperation ()

virtual bool	ContinueHandle ()

void	ExtendDeadline (struct timespec timeout)

virtual void	Fail (uint16_t errCode, uint32_t errNum, const std::string &)

bool	FinishSetup (CURL *curl)

std::pair< XErrorCode, std::string >	GetCallbackError () const

CreateConnCalloutType	GetConnCalloutFunc () const

std::string	GetCurlErrorMessage () const

CURL *	GetCurlHandle () const

OpError	GetError () const

std::chrono::steady_clock::time_point	GetHeaderExpiry () const

std::chrono::steady_clock::time_point	GetOperationExpiry ()

std::unique_ptr< ResponseInfo >	GetResponseInfo ()

int	GetStatusCode () const

std::string	GetStatusMessage () const

bool	GetTriedBoker () const

const std::string &	GetUrl () const

virtual HttpVerb	GetVerb () const =0

bool	HasFailed () const

bool	HeaderTimeoutExpired (const std::chrono::steady_clock::time_point &now)

bool	IsDone () const

bool	IsPaused () const

bool	IsRedirect () const

std::unique_ptr< ResponseInfo >	MoveResponseInfo ()

bool	OperationTimeoutExpired (const std::chrono::steady_clock::time_point &now)

virtual void	OptionsDone ()

virtual RedirectAction	Redirect (std::string &target)

virtual void	ReleaseHandle ()

virtual bool	RequiresOptions () const

virtual void	SetContinueQueue (std::shared_ptr< XrdClHttp::HandlerQueue > queue)

void	SetTriedBoker ()

virtual bool	Setup (CURL *curl, CurlWorker &)

bool	StartConnectionCallout (std::string &err)

std::tuple< uint64_t, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration >	StatisticsReset ()

virtual void	Success ()=0

bool	TransferStalled (uint64_t xfer_bytes, const std::chrono::steady_clock::time_point &now)

bool	UseConnectionCallout ()

virtual int	WaitSocket ()

virtual int	WaitSocketCallback (std::string &err)

Static Public Member Functions
static void	CleanupDnsCache ()

static int	GetDefaultSlowRateBytesSec ()

static int	GetDefaultStallTimeout ()

static const std::string	GetVerbString (HttpVerb)

static void	SetSlowRateBytesSec (int rate)

static void	SetStallTimeout (const std::chrono::steady_clock::duration &stall_interval)

static void	SetStallTimeout (int stall_interval)

Protected Member Functions
int	FailCallback (XErrorCode ecode, const std::string &emsg)

void	SetDone (bool has_failed)

void	SetPaused (bool paused)

bool	SetupNextRequest (const std::string &url, CurlWorker &worker)

void	UpdateBytes (uint64_t bytes)

Protected Attributes
std::unique_ptr< CURL, void()(CURL )>	m_curl

XrdCl::ResponseHandler *	m_handler {nullptr}

HeaderCallout *	m_header_callout

std::atomic< std::chrono::steady_clock::time_point >	m_header_expiry

HeaderParser	m_headers

std::vector< std::pair< std::string, std::string > >	m_headers_list

XrdCl::Log *	m_logger

int	m_minimum_rate {m_minimum_transfer_rate}

std::chrono::steady_clock::time_point	m_operation_expiry

std::string	m_request_url

const std::string	m_url

Static Protected Attributes
static constexpr int	m_default_minimum_rate {1024 * 256}

static int	m_minimum_transfer_rate {CurlOperation::m_default_minimum_rate}

Detailed Description

Definition at line 60 of file XrdClHttpOps.hh.

Member Typedef Documentation

◆ HeaderList

using XrdClHttp::CurlOperation::HeaderList = std::vector<std::pair<std::string, std::string> >

Definition at line 62 of file XrdClHttpOps.hh.

◆ HttpVerb

using XrdClHttp::CurlOperation::HttpVerb = XrdClHttp::HttpVerb

Definition at line 63 of file XrdClHttpOps.hh.

Member Enumeration Documentation

◆ OpError

enum XrdClHttp::CurlOperation::OpError

Enumerator
ErrNone
ErrHeaderTimeout
ErrCallback
ErrOperationTimeout
ErrTransferClientStall
ErrTransferStall
ErrTransferSlow

Definition at line 216 of file XrdClHttpOps.hh.

                  {
         ErrNone,                // No error
         ErrHeaderTimeout,       // Header was not sent back in time
         ErrCallback,            // Error in the read/write callback (e.g., response too large for propfind)
         ErrOperationTimeout,    // Entire curl request operation has timed out
         ErrTransferClientStall, // Transfer stalled while client had paused it (no data was available)
         ErrTransferStall,       // Transfer has stalled, not receiving any data within 60 seconds
         ErrTransferSlow,        // Average transfer rate is below the minimum
     };

◆ RedirectAction

enum XrdClHttp::CurlOperation::RedirectAction

strong

Enumerator
Fail
Reinvoke
ReinvokeAfterAllow

Definition at line 145 of file XrdClHttpOps.hh.

                               {
         Fail, // The redirect parsing failed and Fail() was called
         Reinvoke, // Reinvoke the curl handle, following redirect
         ReinvokeAfterAllow, // Reinvoke the Redirect function once the allowed verbs are known.
     };

Constructor & Destructor Documentation

◆ CurlOperation() [1/3]

XrdClHttp::CurlOperation::CurlOperation	(	XrdCl::ResponseHandler *	handler,
		const std::string &	url,
		struct timespec	timeout,
		XrdCl::Log *	log,
		CreateConnCalloutType	,
		HeaderCallout *	header_callout
	)

◆ CurlOperation() [2/3]

XrdClHttp::CurlOperation::CurlOperation	(	XrdCl::ResponseHandler *	handler,
		const std::string &	url,
		std::chrono::steady_clock::time_point	expiry,
		XrdCl::Log *	log,
		CreateConnCalloutType	,
		HeaderCallout *	header_callout
	)

◆ ~CurlOperation()

CurlOperation::~CurlOperation ( )

virtual

Definition at line 191 of file XrdClHttpOps.cc.

191 {}

◆ CurlOperation() [3/3]

XrdClHttp::CurlOperation::CurlOperation ( const CurlOperation & )

delete

Member Function Documentation

◆ CleanupDnsCache()

void CurlOperation::CleanupDnsCache ( )

static

Definition at line 780 of file XrdClHttpOps.cc.

 {
     auto now = std::chrono::steady_clock::now();
     for (auto it = fake_dns_refcount.begin(); it != fake_dns_refcount.end(); ) {
         if (it->second->count <= 0 && it->second->IsExpired(now)) {
             auto rev_iter = reverse_fake_dns_map.find(*it->first);
             if (rev_iter != reverse_fake_dns_map.end()) {
                 fake_dns_map.erase(rev_iter->second.first);
                 reverse_fake_dns_map.erase(rev_iter);
             }
             it = fake_dns_refcount.erase(it);
         } else {
             ++it;
         }
     }
 }

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ ContinueHandle()

virtual bool XrdClHttp::CurlOperation::ContinueHandle ( )

inlinevirtual

Reimplemented in XrdClHttp::CurlPutOp, and XrdClHttp::CurlReadOp.

Definition at line 139 of file XrdClHttpOps.hh.

139 {return true;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ ExtendDeadline()

void CurlOperation::ExtendDeadline ( struct timespec timeout )

Definition at line 194 of file XrdClHttpOps.cc.

 {
     auto expiry = CalculateExpiry(timeout);
     auto current = m_header_expiry.load(std::memory_order_relaxed);
     while (expiry > current &&
            !m_header_expiry.compare_exchange_weak(current, expiry,
                                                   std::memory_order_relaxed))
         ;
 }

References CalculateExpiry().

Here is the call graph for this function:

◆ Fail()

virtual void XrdClHttp::CurlOperation::Fail	(	uint16_t	errCode,
		uint32_t	errNum,
		const std::string &
	)

virtual

Reimplemented in XrdClHttp::CurlPutOp, XrdClHttp::CurlVectorReadOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlTapeOp, XrdClHttp::CurlOpenOp, and XrdClHttp::CurlOptionsOp.

Referenced by XrdClHttp::CurlOptionsOp::Fail(), XrdClHttp::CurlOpenOp::Fail(), XrdClHttp::CurlTapeOp::Fail(), XrdClHttp::CurlMkcolOp::Fail(), XrdClHttp::CurlWorker::Run(), XrdClHttp::CurlQueryOp::Success(), XrdClHttp::CurlListdirOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

Here is the caller graph for this function:

◆ FailCallback()

int CurlOperation::FailCallback	(	XErrorCode	ecode,
		const std::string &	emsg
	)

protected

Definition at line 221 of file XrdClHttpOps.cc.

                                                                    {
     m_callback_error_code = ecode;
     m_callback_error_str = emsg;
     m_error = OpError::ErrCallback;
     m_logger->Debug(kLogXrdClHttp, "%s", emsg.c_str());
     return 0;
 }

References emsg().

Referenced by XrdClHttp::CurlVectorReadOp::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FinishSetup()

bool CurlOperation::FinishSetup ( CURL * curl )

Definition at line 230 of file XrdClHttpOps.cc.

 {
     if(m_parsed_url)
     {
         InjectBearerToken(*m_parsed_url, m_headers_list, m_logger);
     }
     
     // The client asks every request to carry the headers given by the HttpHeaders
     // environment setting.  HeaderBuilder interprets the contents.
     std::string spec;
     if (auto env = XrdCl::DefaultEnv::GetEnv()) {
         env->GetString("HttpHeaders", spec);
     }
  
     if (!spec.empty()) {
         // Refuse to send anything when the requested headers could not be understood;
         // quietly omitting them changes what the request asks for.
         //
         // Fail here rather than leaving it to the caller, whose failure message for a
         // setup error would suggest the wrong cause entirely.
         HeaderList requested;
         if (!HeaderBuilder::Build(spec, requested)) {
             m_logger->Error(kLogXrdClHttp, "Not sending request to %s: the requested"
                 " headers could not be used", m_url.c_str());
             Fail(XrdCl::errInvalidArgs, EINVAL, "Invalid header requested");
             return false;
         }
         HeaderBuilder::AppendMissing(requested, m_headers_list);
     }
  
     if (!m_header_callout) {
         m_header_slist.reset();
         for (const auto &header : m_headers_list) {
             m_header_slist.reset(curl_slist_append(m_header_slist.release(),
                 (header.first + ": " + header.second).c_str()));
         }
         return curl_easy_setopt(curl, CURLOPT_HTTPHEADER, m_header_slist.get()) == CURLE_OK;
     }
     const auto &verb = GetVerbString(GetVerb());
  
     auto extra_headers = m_header_callout->GetHeaders(
         verb, m_request_url, m_headers_list);
     if (!extra_headers) {
         m_logger->Error(kLogXrdClHttp,
             "Failed to get headers from header callout for %s",
             m_request_url.c_str());
         return false;
     }
     m_header_slist.reset();
     for (const auto &header : *extra_headers) {
         if (HeaderBuilder::CompareIgnoreCase(header.first, "Content-Length")) {
             auto upload_size = std::stoull(header.second);
             curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, upload_size);
             continue;
         }
         m_header_slist.reset(curl_slist_append(m_header_slist.release(),
             (header.first + ": " + header.second).c_str()));
     }
     return curl_easy_setopt(curl, CURLOPT_HTTPHEADER, m_header_slist.get()) == CURLE_OK;
 }

References XrdClHttp::HeaderBuilder::AppendMissing(), XrdClHttp::HeaderBuilder::Build(), XrdClHttp::HeaderBuilder::CompareIgnoreCase(), XrdCl::errInvalidArgs, XrdCl::DefaultEnv::GetEnv(), XrdClHttp::InjectBearerToken(), and stoull().

Referenced by XrdClHttp::CurlWorker::Run(), and XrdClHttp::CurlTapeOp::Success().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCallbackError()

std::pair<XErrorCode, std::string> XrdClHttp::CurlOperation::GetCallbackError ( ) const

inline

Definition at line 236 of file XrdClHttpOps.hh.

236 {return std::make_pair(m_callback_error_code, m_callback_error_str);}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetConnCalloutFunc()

CreateConnCalloutType XrdClHttp::CurlOperation::GetConnCalloutFunc ( ) const

inline

Definition at line 92 of file XrdClHttpOps.hh.

92 {return m_conn_callout;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetCurlErrorMessage()

std::string XrdClHttp::CurlOperation::GetCurlErrorMessage ( ) const

inline

Definition at line 262 of file XrdClHttpOps.hh.

                                           {
         if (m_curl_error_buffer[0] != '\0')
             return m_curl_error_buffer;
         return "";
     }

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetCurlHandle()

CURL* XrdClHttp::CurlOperation::GetCurlHandle ( ) const

inline

Definition at line 227 of file XrdClHttpOps.hh.

227 {return m_curl.get();}

XrdClHttp::CurlOperation::m_curl

std::unique_ptr< CURL, void(*)(CURL *)> m_curl

Definition: XrdClHttpOps.hh:416

References m_curl.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetDefaultSlowRateBytesSec()

static int XrdClHttp::CurlOperation::GetDefaultSlowRateBytesSec ( )

inlinestatic

Definition at line 288 of file XrdClHttpOps.hh.

     {
         return m_default_minimum_rate;
     }

References m_default_minimum_rate.

◆ GetDefaultStallTimeout()

static int XrdClHttp::CurlOperation::GetDefaultStallTimeout ( )

inlinestatic

Definition at line 282 of file XrdClHttpOps.hh.

     {
         return std::chrono::duration_cast<std::chrono::seconds>(m_default_stall_interval).count();
     }

◆ GetError()

OpError XrdClHttp::CurlOperation::GetError ( ) const

inline

Definition at line 230 of file XrdClHttpOps.hh.

230 {return m_error;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetHeaderExpiry()

std::chrono::steady_clock::time_point XrdClHttp::CurlOperation::GetHeaderExpiry ( ) const

inline

Definition at line 103 of file XrdClHttpOps.hh.

                                                             {
         return m_header_expiry.load(std::memory_order_relaxed);
     }

References m_header_expiry.

Referenced by XrdClHttp::CurlStatOp::CurlStatOp(), and GetOperationExpiry().

Here is the caller graph for this function:

◆ GetOperationExpiry()

std::chrono::steady_clock::time_point XrdClHttp::CurlOperation::GetOperationExpiry ( )

inline

Definition at line 116 of file XrdClHttpOps.hh.

                                                          {
         if (m_last_xfer != std::chrono::steady_clock::time_point()) {
             return m_last_xfer + m_stall_interval;
         }
         // Headers have arrived but no payload byte has been accounted for yet.
         // The header deadline no longer applies (HeaderTimeoutExpired stops
         // enforcing it at the same point), so anchor the stall clock on the
         // last header activity instead of reviving a deadline that is moot.
         if (m_received_header) {
             return m_header_lastop + m_stall_interval;
         }
         return GetHeaderExpiry();
     }

References GetHeaderExpiry().

Here is the call graph for this function:

◆ GetResponseInfo()

std::unique_ptr<ResponseInfo> XrdClHttp::CurlOperation::GetResponseInfo ( )

◆ GetStatusCode()

int XrdClHttp::CurlOperation::GetStatusCode ( ) const

inline

Definition at line 239 of file XrdClHttpOps.hh.

239 {return m_headers.GetStatusCode();}

XrdClHttp::CurlOperation::m_headers

HeaderParser m_headers

Definition: XrdClHttpOps.hh:417

XrdClHttp::HeaderParser::GetStatusCode

int GetStatusCode() const

Definition: XrdClHttpUtil.hh:112

References XrdClHttp::HeaderParser::GetStatusCode(), and m_headers.

Referenced by XrdClHttp::CurlTapeOp::Fail(), XrdClHttp::CurlMkcolOp::Fail(), XrdClHttp::CurlWorker::Run(), XrdClHttp::CurlTapeOp::Success(), and XrdClHttp::CurlVectorReadOp::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStatusMessage()

std::string XrdClHttp::CurlOperation::GetStatusMessage ( ) const

inline

Definition at line 242 of file XrdClHttpOps.hh.

242 {return m_headers.GetStatusMessage();}

XrdClHttp::HeaderParser::GetStatusMessage

std::string GetStatusMessage() const

Definition: XrdClHttpUtil.hh:137

References XrdClHttp::HeaderParser::GetStatusMessage(), and m_headers.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTriedBoker()

bool XrdClHttp::CurlOperation::GetTriedBoker ( ) const

inline

Definition at line 177 of file XrdClHttpOps.hh.

177 {return m_tried_broker;} // Returns true if the connection broker has been tried.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetUrl()

const std::string& XrdClHttp::CurlOperation::GetUrl ( ) const

inline

Definition at line 187 of file XrdClHttpOps.hh.

187 {return m_request_url;}

References m_request_url.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ GetVerb()

virtual HttpVerb XrdClHttp::CurlOperation::GetVerb ( ) const

pure virtual

Implemented in XrdClHttp::CurlPutOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlPgReadOp, XrdClHttp::CurlVectorReadOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlTapeOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlChecksumOp, XrdClHttp::CurlStatOp, and XrdClHttp::CurlOptionsOp.

◆ GetVerbString()

const std::string CurlOperation::GetVerbString ( CurlOperation::HttpVerb verb )

static

Definition at line 292 of file XrdClHttpOps.cc.

 {
     switch (verb) {
     case HttpVerb::COPY:
         return "COPY";
     case HttpVerb::DELETE:
         return "DELETE";
     case HttpVerb::GET:
         return "GET";
     case HttpVerb::POST:
         return "POST";
     case HttpVerb::HEAD:
         return "HEAD";
     case HttpVerb::MKCOL:
         return "MKCOL";
     case HttpVerb::OPTIONS:
         return "OPTIONS";
     case HttpVerb::PROPFIND:
         return "PROPFIND";
     case HttpVerb::PUT:
         return "PUT";
     case HttpVerb::Count:
         return "UNKNOWN";
     }
     return "UNKNOWN";
 }

Referenced by XrdClHttp::CurlWorker::GetMonitoringJson().

Here is the caller graph for this function:

◆ HasFailed()

bool XrdClHttp::CurlOperation::HasFailed ( ) const

inline

Definition at line 251 of file XrdClHttpOps.hh.

251 {return m_has_failed.load(std::memory_order_acquire);}

◆ HeaderTimeoutExpired()

bool CurlOperation::HeaderTimeoutExpired ( const std::chrono::steady_clock::time_point & now )

Definition at line 502 of file XrdClHttpOps.cc.

                                                                               {
     if (m_received_header) return false;
  
     if (now > GetHeaderExpiry()) {
         if (m_error == OpError::ErrNone) m_error = OpError::ErrHeaderTimeout;
         return true;
     }
     return false;
 }

◆ IsDone()

bool XrdClHttp::CurlOperation::IsDone ( ) const

inline

Definition at line 245 of file XrdClHttpOps.hh.

245 {return m_done;}

Referenced by XrdClHttp::CurlReadOp::ContinueHandle(), and XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ IsPaused()

bool XrdClHttp::CurlOperation::IsPaused ( ) const

inline

Definition at line 248 of file XrdClHttpOps.hh.

248 {return m_is_paused;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ IsRedirect()

bool XrdClHttp::CurlOperation::IsRedirect ( ) const

inline

Definition at line 161 of file XrdClHttpOps.hh.

161 {return m_headers.GetStatusCode() >= 300 && m_headers.GetStatusCode() < 400;}

References XrdClHttp::HeaderParser::GetStatusCode(), and m_headers.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MoveResponseInfo()

std::unique_ptr<ResponseInfo> XrdClHttp::CurlOperation::MoveResponseInfo ( )

inline

Definition at line 233 of file XrdClHttpOps.hh.

233 {return std::move(m_response_info);}

Referenced by XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlMkcolOp::Success(), XrdClHttp::CurlListdirOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

Here is the caller graph for this function:

◆ OperationTimeoutExpired()

bool CurlOperation::OperationTimeoutExpired ( const std::chrono::steady_clock::time_point & now )

Definition at line 513 of file XrdClHttpOps.cc.

                                                                                  {
     if (m_operation_expiry == std::chrono::steady_clock::time_point{} ||
         !m_received_header) {
         return false;
     }
  
     if (now > m_operation_expiry) {
         if (m_error == OpError::ErrNone) m_error = OpError::ErrOperationTimeout;
         return true;
     }
     return false;
 }

◆ OptionsDone()

virtual void XrdClHttp::CurlOperation::OptionsDone ( )

inlinevirtual

Reimplemented in XrdClHttp::CurlChecksumOp, and XrdClHttp::CurlStatOp.

Definition at line 184 of file XrdClHttpOps.hh.

184 {}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ Redirect()

CurlOperation::RedirectAction CurlOperation::Redirect ( std::string & target )

virtual

Reimplemented in XrdClHttp::CurlChecksumOp, and XrdClHttp::CurlStatOp.

Definition at line 352 of file XrdClHttpOps.cc.

 {
     m_callout.reset();
     m_conn_callout_result = -1;
     m_conn_callout_listener = -1;
     m_tried_broker = false;
  
     auto location = m_headers.GetLocation();
     if (location.empty()) {
         m_logger->Warning(kLogXrdClHttp, "After request to %s, server returned a redirect with no new location", m_request_url.c_str());
         Fail(XrdCl::errErrorResponse, kXR_ServerError, "Server returned redirect without updated location");
         return RedirectAction::Fail;
     }
     if (location.size() && location[0] == '/') { // hostname not included in the location - redirect to self.
         std::string_view orig_url(m_request_url);
         auto scheme_loc = orig_url.find("://");
         if (scheme_loc == std::string_view::npos) {
             Fail(XrdCl::errErrorResponse, kXR_ServerError, "Server returned a location with unknown hostname");
             return RedirectAction::Fail;
         }
         auto path_loc = orig_url.find('/', scheme_loc + 3);
         if (path_loc == std::string_view::npos) {
             location = m_request_url + location;
         } else {
             location = std::string(orig_url.substr(0, path_loc)) + location;
         }
     }
     m_logger->Debug(kLogXrdClHttp, "Request for %s redirected to %s", m_request_url.c_str(), location.c_str());
     m_request_url = DavToHttp(location);
     target = m_request_url;
     curl_easy_setopt(m_curl.get(), CURLOPT_URL, m_request_url.c_str());
     int disable_x509;
     auto env = XrdCl::DefaultEnv::GetEnv();
     if (env->GetInt("HttpDisableX509", disable_x509) && !disable_x509) {
         std::string cert, key;
         env->GetString("HttpClientCertFile", cert);
         env->GetString("HttpClientKeyFile", key);
         if (!cert.empty())
             curl_easy_setopt(m_curl.get(), CURLOPT_SSLCERT, cert.c_str());
         if (!key.empty())
             curl_easy_setopt(m_curl.get(), CURLOPT_SSLKEY, key.c_str());
     }
     m_headers = HeaderParser();
  
     if (m_conn_callout) {
         auto conn_callout = m_conn_callout(m_request_url, *m_response_info);
         if (conn_callout != nullptr) {
  
             auto [host, port] = ParseHostPort(m_request_url);
             if (host.empty() || port == -1) {
                 Fail(XrdCl::errInternal, 0, "Failed to parse host and port from URL " + m_request_url);
                 return RedirectAction::Fail;
             }
             auto fake_addr = GetFakeEndpointForHost(host, port);
             if (!fake_addr || fake_addr->empty()) {
                 Fail(XrdCl::errInternal, 0, "Failed to generate a fake address for host " + host);
                 return RedirectAction::Fail;
             }
             m_resolve_slist.reset(curl_slist_append(m_resolve_slist.release(),
                 (host + ":" + std::to_string(port) + ":" + *fake_addr).c_str()));
             m_logger->Debug(kLogXrdClHttp, "For connection callout in redirect, mapping %s:%d -> %s", host.c_str(), port, fake_addr->c_str());
  
             m_callout.reset(conn_callout);
             std::string err;
             SetTriedBoker();
             // BeginCallout takes the expiration by non-const reference; hand it
             // a copy rather than the atomic's storage.
             auto expiry = GetHeaderExpiry();
             if ((m_conn_callout_listener = m_callout->BeginCallout(err, expiry)) == -1) {
                 auto errMsg = "Failed to start a connection callout request: " + err;
                 Fail(XrdCl::errInternal, 0, errMsg.c_str());
                 return RedirectAction::Fail;
             }
             curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETFUNCTION, CurlOperation::OpenSocketCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETFUNCTION, CurlOperation::CloseSocketCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETDATA, this);
             curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETDATA, fake_addr);
             curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTFUNCTION, CurlOperation::SockOptCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTDATA, this);
             curl_easy_setopt(m_curl.get(), CURLOPT_CONNECT_TO, m_resolve_slist.get());
         }
     }
     m_received_header = false;
  
     m_last_header_reset = m_last_reset = m_header_start = m_start_op = m_header_lastop = std::chrono::steady_clock::now();
     return RedirectAction::Reinvoke;
 }

References XrdCl::errErrorResponse, XrdCl::errInternal, XrdCl::DefaultEnv::GetEnv(), and kXR_ServerError.

Referenced by XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlChecksumOp::Redirect(), and XrdClHttp::CurlWorker::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReleaseHandle()

void CurlOperation::ReleaseHandle ( )

virtual

Reimplemented in XrdClHttp::CurlPutOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlVectorReadOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlTapeOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlChecksumOp, XrdClHttp::CurlOpenOp, XrdClHttp::CurlStatOp, and XrdClHttp::CurlOptionsOp.

Definition at line 688 of file XrdClHttpOps.cc.

 {
     m_conn_callout_listener = -1;
     m_conn_callout_result = -1;
     m_tried_broker = false;
     m_callout.reset();
  
     if (m_curl == nullptr) return;
     curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SSLCERT, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SSLKEY, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_HTTPHEADER, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_CONNECT_TO, nullptr);
     m_header_slist.reset();
     m_curl.release();
 }

Referenced by XrdClHttp::CurlOptionsOp::ReleaseHandle(), XrdClHttp::CurlStatOp::ReleaseHandle(), XrdClHttp::CurlDeleteOp::ReleaseHandle(), XrdClHttp::CurlMkcolOp::ReleaseHandle(), XrdClHttp::CurlTapeOp::ReleaseHandle(), XrdClHttp::CurlReadOp::ReleaseHandle(), XrdClHttp::CurlVectorReadOp::ReleaseHandle(), XrdClHttp::CurlListdirOp::ReleaseHandle(), XrdClHttp::CurlCopyOp::ReleaseHandle(), XrdClHttp::CurlPutOp::ReleaseHandle(), and XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ RequiresOptions()

virtual bool XrdClHttp::CurlOperation::RequiresOptions ( ) const

inlinevirtual

Reimplemented in XrdClHttp::CurlStatOp.

Definition at line 181 of file XrdClHttpOps.hh.

181 {return false;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ SetContinueQueue()

virtual void XrdClHttp::CurlOperation::SetContinueQueue ( std::shared_ptr< XrdClHttp::HandlerQueue > queue )

inlinevirtual

Reimplemented in XrdClHttp::CurlPutOp, and XrdClHttp::CurlReadOp.

Definition at line 143 of file XrdClHttpOps.hh.

143 {}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ SetDone()

void XrdClHttp::CurlOperation::SetDone ( bool has_failed )

inlineprotected

Definition at line 410 of file XrdClHttpOps.hh.

410 {m_done = true; m_has_failed.store(has_failed, std::memory_order_release);}

Here is the caller graph for this function:

◆ SetPaused()

void CurlOperation::SetPaused ( bool paused )

protected

Definition at line 451 of file XrdClHttpOps.cc.

                                     {
     m_is_paused = paused;
     if (m_is_paused) {
         m_pause_start = std::chrono::steady_clock::now();
     } else if (m_pause_start != std::chrono::steady_clock::time_point{}) {
         m_pause_duration += std::chrono::steady_clock::now() - m_pause_start;
         m_pause_start = std::chrono::steady_clock::time_point{};
     }
 }

Referenced by XrdClHttp::CurlReadOp::ContinueHandle(), XrdClHttp::CurlPutOp::ContinueHandle(), XrdClHttp::CurlReadOp::Pause(), and XrdClHttp::CurlPutOp::Pause().

Here is the caller graph for this function:

◆ SetSlowRateBytesSec()

static void XrdClHttp::CurlOperation::SetSlowRateBytesSec ( int rate )

inlinestatic

Definition at line 294 of file XrdClHttpOps.hh.

     {
         m_minimum_transfer_rate = rate;
     }

References m_minimum_transfer_rate.

◆ SetStallTimeout() [1/2]

static void XrdClHttp::CurlOperation::SetStallTimeout ( const std::chrono::steady_clock::duration & stall_interval )

inlinestatic

Definition at line 276 of file XrdClHttpOps.hh.

     {
         m_stall_interval = stall_interval;
     }

◆ SetStallTimeout() [2/2]

static void XrdClHttp::CurlOperation::SetStallTimeout ( int stall_interval )

inlinestatic

Definition at line 269 of file XrdClHttpOps.hh.

     {
         std::chrono::seconds seconds{stall_interval};
         m_stall_interval = std::chrono::duration_cast<std::chrono::steady_clock::duration>(seconds);
     }

◆ SetTriedBoker()

void XrdClHttp::CurlOperation::SetTriedBoker ( )

inline

Definition at line 178 of file XrdClHttpOps.hh.

178 {m_tried_broker = true;} // Note that the connection broker has been attempted.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ Setup()

bool CurlOperation::Setup	(	CURL *	curl,
		CurlWorker &	worker
	)

virtual

Reimplemented in XrdClHttp::CurlTapeOp, XrdClHttp::CurlPutOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlVectorReadOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlChecksumOp, XrdClHttp::CurlStatOp, and XrdClHttp::CurlOptionsOp.

Definition at line 575 of file XrdClHttpOps.cc.

 {
     if (curl == nullptr) {
         throw std::runtime_error("Unable to setup curl operation with no handle");
     }
     struct timespec now;
     if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) {
         throw std::runtime_error("Unable to get current time");
     }
  
     m_pause_start = {};
     m_last_header_reset = m_last_reset = m_start_op = m_header_start = m_header_lastop = std::chrono::steady_clock::now();
  
     m_curl.reset(curl);
     m_curl_error_buffer[0] = '\0';
     curl_easy_setopt(m_curl.get(), CURLOPT_URL, m_request_url.c_str());
     curl_easy_setopt(m_curl.get(), CURLOPT_ERRORBUFFER, m_curl_error_buffer);
     curl_easy_setopt(m_curl.get(), CURLOPT_HEADERFUNCTION, CurlStatOp::HeaderCallback);
     curl_easy_setopt(m_curl.get(), CURLOPT_HEADERDATA, this);
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEFUNCTION, NullCallback);
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_XFERINFOFUNCTION, CurlOperation::XferInfoCallback);
     curl_easy_setopt(m_curl.get(), CURLOPT_XFERINFODATA, this);
     curl_easy_setopt(m_curl.get(), CURLOPT_NOPROGRESS, 0L);
     // Note: libcurl is not threadsafe unless this option is set.
     // Before we set it, we saw deadlocks (and partial deadlocks) in practice.
     curl_easy_setopt(m_curl.get(), CURLOPT_NOSIGNAL, 1L);
  
     m_parsed_url = std::make_unique<XrdCl::URL>(m_request_url);
     auto env = XrdCl::DefaultEnv::GetEnv();
     int disable_x509;
     if (env->GetInt("HttpDisableX509", disable_x509) && !disable_x509) {
         auto [cert, key] = worker.ClientX509CertKeyFile();
         if (!cert.empty()) {
             m_logger->Debug(kLogXrdClHttp,
                 "Using client X.509 credential found at %s", cert.c_str());
             curl_easy_setopt(m_curl.get(), CURLOPT_SSLCERT, cert.c_str());
             if (key.empty()) {
                 m_logger->Error(kLogXrdClHttp,
                     "X.509 client credential specified but not the client key");
             } else {
                 curl_easy_setopt(m_curl.get(), CURLOPT_SSLKEY, key.c_str());
             }
         }
     }
  
     if (m_conn_callout) {
         ResponseInfo info;
         auto callout = m_conn_callout(m_request_url, info);
         if (callout) {
             m_callout.reset(callout);
             m_conn_callout_listener = -1;
             m_conn_callout_result = -1;
             m_tried_broker = false;
  
             auto [host, port] = ParseHostPort(m_request_url);
             if (host.empty() || port == -1) {
                 throw std::runtime_error(
                     "Failed to parse host and port from URL " + m_request_url);
             }
             auto fake_addr = GetFakeEndpointForHost(host, port);
             if (!fake_addr || fake_addr->empty()) {
                 throw std::runtime_error("Failed to generate a fake address for host " + host);
             }
             m_resolve_slist.reset(curl_slist_append(m_resolve_slist.release(),
                 (host + ":" + std::to_string(port) + ":" + *fake_addr).c_str()));
             m_logger->Debug(kLogXrdClHttp, "For connection callout in operation setup, mapping %s:%d -> %s", host.c_str(), port, fake_addr->c_str());
  
             curl_easy_setopt(m_curl.get(), CURLOPT_CONNECT_TO, m_resolve_slist.get());
  
             curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETFUNCTION, CurlOperation::OpenSocketCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETFUNCTION, CurlOperation::CloseSocketCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETDATA, this);
             curl_easy_setopt(m_curl.get(), CURLOPT_CLOSESOCKETDATA, fake_addr);
             curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTFUNCTION, CurlOperation::SockOptCallback);
             curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTDATA, this);
         }
     }
  
     return true;
 }

References XrdClHttp::CurlWorker::ClientX509CertKeyFile(), and XrdCl::DefaultEnv::GetEnv().

Referenced by XrdClHttp::CurlWorker::Run(), XrdClHttp::CurlOptionsOp::Setup(), XrdClHttp::CurlStatOp::Setup(), XrdClHttp::CurlDeleteOp::Setup(), XrdClHttp::CurlMkcolOp::Setup(), XrdClHttp::CurlReadOp::Setup(), XrdClHttp::CurlVectorReadOp::Setup(), XrdClHttp::CurlListdirOp::Setup(), XrdClHttp::CurlCopyOp::Setup(), XrdClHttp::CurlPutOp::Setup(), and XrdClHttp::CurlTapeOp::Setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetupNextRequest()

bool CurlOperation::SetupNextRequest	(	const std::string &	url,
		CurlWorker &	worker
	)

protected

Definition at line 658 of file XrdClHttpOps.cc.

 {
     if (!m_curl) return false;
  
     curl_easy_reset(m_curl.get());
     ConfigureHandle(m_curl.get(), false);
  
     m_request_url = DavToHttp(url);
     m_headers = HeaderParser();
     m_headers_list.clear();
     m_header_slist.reset();
     m_response_info.reset();
     m_resolve_slist.reset();
     m_callout.reset();
     m_conn_callout_listener = -1;
     m_conn_callout_result = -1;
     m_tried_broker = false;
     m_received_header = false;
     m_error = OpError::ErrNone;
     m_callback_error_code = kXR_noErrorYet;
     m_callback_error_str.clear();
     m_last_xfer = {};
     m_last_xfer_count = 0;
     m_ema_rate = -1.0;
  
     CURL *curl = m_curl.release();
     return CurlOperation::Setup(curl, worker);
 }

References XrdClHttp::ConfigureHandle(), and kXR_noErrorYet.

Referenced by XrdClHttp::CurlTapeOp::Success().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartConnectionCallout()

bool CurlOperation::StartConnectionCallout ( std::string & err )

Definition at line 462 of file XrdClHttpOps.cc.

 {
     auto expiry = GetHeaderExpiry();
     if ((m_conn_callout_listener = m_callout->BeginCallout(err, expiry)) == -1) {
         err = "Failed to start a callout for a socket connection: " + err;
         Fail(XrdCl::errInternal, 1, err.c_str());
         return false;
     }
     return true;
 }

References XrdCl::errInternal.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ StatisticsReset()

std::tuple< uint64_t, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration > CurlOperation::StatisticsReset ( )

Definition at line 474 of file XrdClHttpOps.cc.

                                {
     auto now = std::chrono::steady_clock::now();
     std::chrono::steady_clock::duration pre_header{}, post_header{}, pause_duration{};
     if (m_received_header) {
         if (m_last_header_reset < m_header_start) {
             pre_header = m_header_start - m_last_header_reset;
             m_last_header_reset = m_header_start;
         }
         post_header = now - ((m_last_reset < m_header_start) ? m_header_start : m_last_reset);
         m_last_reset = now;
     } else {
         pre_header = now - m_last_header_reset;
         m_last_header_reset = now;
     }
     if (IsPaused()) {
         m_pause_duration += now - m_pause_start;
         m_pause_start = now;
     }
     if (m_pause_duration != std::chrono::steady_clock::duration::zero()) {
         pause_duration = m_pause_duration;
         m_pause_duration = std::chrono::steady_clock::duration::zero();
     }
     auto bytes = m_bytes;
     m_bytes = 0;
     return {bytes, pre_header, post_header, pause_duration};
 }

◆ Success()

virtual void XrdClHttp::CurlOperation::Success ( )

pure virtual

Implemented in XrdClHttp::CurlPutOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlPgReadOp, XrdClHttp::CurlVectorReadOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlTapeOp, XrdClHttp::CurlQueryOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlChecksumOp, XrdClHttp::CurlOpenOp, XrdClHttp::CurlStatOp, and XrdClHttp::CurlOptionsOp.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ TransferStalled()

bool CurlOperation::TransferStalled	(	uint64_t	xfer_bytes,
		const std::chrono::steady_clock::time_point &	now
	)

Definition at line 527 of file XrdClHttpOps.cc.

 {
     // First, check to see how long it's been since any data was sent.
     if (m_last_xfer == std::chrono::steady_clock::time_point()) {
         m_last_xfer = m_header_lastop;
     }
     auto elapsed = now - m_last_xfer;
     uint64_t xfer_diff = 0;
     if (xfer > m_last_xfer_count) {
         xfer_diff = xfer - m_last_xfer_count;
         m_last_xfer_count = xfer;
         m_last_xfer = now;
     }
  
     // If progress is made in this callback do not classify as stalled
     if (elapsed > m_stall_interval && xfer_diff == 0) {
         if (m_error == OpError::ErrNone) m_error = IsPaused() ? OpError::ErrTransferClientStall : OpError::ErrTransferStall;
         return true;
     }
  
     // Curl updated us with new timing but the byte count hasn't changed; no need to update the EMA.
     if (xfer_diff == 0) {
         return false;
     }
  
     // If the transfer is not stalled, then we check to see if the exponentially-weighted
     // moving average of the transfer rate is below the minimum.
  
     // If the stall interval since the last header hasn't passed, then we don't check for slow transfers.
     auto elapsed_since_last_headerop = now - m_header_lastop;
     if (elapsed_since_last_headerop < m_stall_interval) {
         return false;
     } else if (m_ema_rate < 0) {
         m_ema_rate = xfer / std::chrono::duration<double>(elapsed_since_last_headerop).count();
     }
     // Calculate the exponential moving average of the transfer rate.
     double elapsed_seconds = std::chrono::duration<double>(elapsed).count();
     auto recent_rate = static_cast<double>(xfer_diff) / elapsed_seconds;
     auto alpha = 1.0 - exp(-elapsed_seconds / std::chrono::duration<double>(m_stall_interval).count());
     m_ema_rate = (1.0 - alpha) * m_ema_rate + alpha * recent_rate;
     if (m_ema_rate < static_cast<double>(m_minimum_rate)) {
         if (m_error == OpError::ErrNone) m_error = OpError::ErrTransferSlow;
         return true;
     }
     return false;
 }

◆ UpdateBytes()

void XrdClHttp::CurlOperation::UpdateBytes ( uint64_t bytes )

inlineprotected

Definition at line 307 of file XrdClHttpOps.hh.

307 {m_bytes += bytes;}

Referenced by XrdClHttp::CurlVectorReadOp::Write().

Here is the caller graph for this function:

◆ UseConnectionCallout()

bool XrdClHttp::CurlOperation::UseConnectionCallout ( )

inline

Definition at line 176 of file XrdClHttpOps.hh.

176 {return m_callout.get();} // Returns true if the callout should be tried.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ WaitSocket()

virtual int XrdClHttp::CurlOperation::WaitSocket ( )

inlinevirtual

Definition at line 164 of file XrdClHttpOps.hh.

164 {return m_conn_callout_listener;}

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

◆ WaitSocketCallback()

int CurlOperation::WaitSocketCallback ( std::string & err )

virtual

Definition at line 813 of file XrdClHttpOps.cc.

 {
     m_conn_callout_result = m_callout ? m_callout->FinishCallout(err) : -1;
     if (m_callout && m_conn_callout_result == -1) {
         m_logger->Error(kLogXrdClHttp, "Error when getting socket callout: %s", err.c_str());
     } else if (m_callout) {
         m_logger->Debug(kLogXrdClHttp, "Got callback socket %d", m_conn_callout_result);
     }
     return m_conn_callout_result;
 }

Member Data Documentation

◆ m_curl

std::unique_ptr<CURL, void(*)(CURL *)> XrdClHttp::CurlOperation::m_curl

protected

Definition at line 416 of file XrdClHttpOps.hh.

◆ m_default_minimum_rate

constexpr int XrdClHttp::CurlOperation::m_default_minimum_rate {1024 * 256}

staticconstexprprotected

Definition at line 319 of file XrdClHttpOps.hh.

Referenced by GetDefaultSlowRateBytesSec().

◆ m_handler

XrdCl::ResponseHandler* XrdClHttp::CurlOperation::m_handler {nullptr}

protected

◆ m_header_callout

HeaderCallout* XrdClHttp::CurlOperation::m_header_callout

protected

Definition at line 339 of file XrdClHttpOps.hh.

◆ m_header_expiry

std::atomic<std::chrono::steady_clock::time_point> XrdClHttp::CurlOperation::m_header_expiry

protected

Definition at line 336 of file XrdClHttpOps.hh.

Referenced by GetHeaderExpiry().

◆ m_headers

HeaderParser XrdClHttp::CurlOperation::m_headers

protected

Definition at line 417 of file XrdClHttpOps.hh.

Referenced by XrdClHttp::CurlStatOp::GetStatInfo(), GetStatusCode(), GetStatusMessage(), IsRedirect(), XrdClHttp::CurlStatOp::OptionsDone(), XrdClHttp::CurlPrefetchOpenOp::Pause(), XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlVectorReadOp::SetSeparator(), XrdClHttp::CurlVectorReadOp::SetStatusCode(), XrdClHttp::CurlOptionsOp::Success(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlQueryOp::Success(), and XrdClHttp::CurlVectorReadOp::Write().

◆ m_headers_list

std::vector<std::pair<std::string, std::string> > XrdClHttp::CurlOperation::m_headers_list

protected

Definition at line 418 of file XrdClHttpOps.hh.

Referenced by XrdClHttp::CurlCopyOp::CurlCopyOp(), XrdClHttp::CurlStatOp::OptionsDone(), XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlStatOp::Setup(), XrdClHttp::CurlChecksumOp::Setup(), XrdClHttp::CurlReadOp::Setup(), XrdClHttp::CurlVectorReadOp::Setup(), and XrdClHttp::CurlListdirOp::Setup().

◆ m_logger

XrdCl::Log* XrdClHttp::CurlOperation::m_logger

protected

◆ m_minimum_rate

int XrdClHttp::CurlOperation::m_minimum_rate {m_minimum_transfer_rate}

protected

Definition at line 327 of file XrdClHttpOps.hh.

Referenced by XrdClHttp::CurlCopyOp::CurlCopyOp(), and XrdClHttp::CurlListdirOp::CurlListdirOp().

◆ m_minimum_transfer_rate

int CurlOperation::m_minimum_transfer_rate {CurlOperation::m_default_minimum_rate}

staticprotected

Definition at line 324 of file XrdClHttpOps.hh.

Referenced by SetSlowRateBytesSec().

◆ m_operation_expiry

std::chrono::steady_clock::time_point XrdClHttp::CurlOperation::m_operation_expiry

protected

Definition at line 330 of file XrdClHttpOps.hh.

Referenced by XrdClHttp::CurlStatOp::CurlStatOp().

◆ m_request_url

std::string XrdClHttp::CurlOperation::m_request_url

protected

Definition at line 414 of file XrdClHttpOps.hh.

Referenced by GetUrl(), and XrdClHttp::CurlTapeOp::Setup().

◆ m_url

const std::string XrdClHttp::CurlOperation::m_url

protected

Definition at line 411 of file XrdClHttpOps.hh.

Referenced by XrdClHttp::CurlOptionsOp::Fail(), XrdClHttp::CurlStatOp::OptionsDone(), XrdClHttp::CurlStatOp::RequiresOptions(), XrdClHttp::CurlStatOp::Setup(), XrdClHttp::CurlOptionsOp::Success(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlListdirOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ HeaderList

◆ HttpVerb

Member Enumeration Documentation

◆ OpError

◆ RedirectAction

Constructor & Destructor Documentation

◆ CurlOperation() [1/3]

◆ CurlOperation() [2/3]

◆ ~CurlOperation()

◆ CurlOperation() [3/3]

Member Function Documentation

◆ CleanupDnsCache()

◆ ContinueHandle()

◆ ExtendDeadline()

◆ Fail()

◆ FailCallback()

◆ FinishSetup()

◆ GetCallbackError()

◆ GetConnCalloutFunc()

◆ GetCurlErrorMessage()

◆ GetCurlHandle()

◆ GetDefaultSlowRateBytesSec()

◆ GetDefaultStallTimeout()

◆ GetError()

◆ GetHeaderExpiry()

◆ GetOperationExpiry()

◆ GetResponseInfo()

◆ GetStatusCode()

◆ GetStatusMessage()

◆ GetTriedBoker()

◆ GetUrl()

◆ GetVerb()

◆ GetVerbString()

◆ HasFailed()

◆ HeaderTimeoutExpired()

◆ IsDone()

◆ IsPaused()

◆ IsRedirect()

◆ MoveResponseInfo()

◆ OperationTimeoutExpired()

◆ OptionsDone()

◆ Redirect()

◆ ReleaseHandle()

◆ RequiresOptions()

◆ SetContinueQueue()

◆ SetDone()

◆ SetPaused()

◆ SetSlowRateBytesSec()

◆ SetStallTimeout() [1/2]

◆ SetStallTimeout() [2/2]

◆ SetTriedBoker()

◆ Setup()

◆ SetupNextRequest()

◆ StartConnectionCallout()

◆ StatisticsReset()

◆ Success()

◆ TransferStalled()

◆ UpdateBytes()

◆ UseConnectionCallout()

◆ WaitSocket()

◆ WaitSocketCallback()

Member Data Documentation

◆ m_curl

◆ m_default_minimum_rate

◆ m_handler

◆ m_header_callout

◆ m_header_expiry

◆ m_headers

◆ m_headers_list

◆ m_logger

◆ m_minimum_rate

◆ m_minimum_transfer_rate