XrdClHttp::CurlOperation Class Reference

#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 class 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]

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

Definition at line 168 of file XrdClHttpOps.cc.

                                   :
    CurlOperation::CurlOperation(handler, url, CalculateExpiry(timeout), logger, callout, header_callout)
    {}

References CurlOperation(), and CalculateExpiry().

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

Here is the call graph for this function:

Here is the caller graph for this function:

CurlOperation() [2/3]

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

Definition at line 174 of file XrdClHttpOps.cc.

                                                                  :
    m_header_expiry(expiry),
    m_header_callout(header_callout),
    m_last_reset(std::chrono::steady_clock::now()),
    m_last_header_reset(m_last_reset),
    m_start_op(m_last_reset),
    m_header_start(m_last_reset),
    m_conn_callout(callout),
    m_url(DavToHttp(url)),
    m_request_url(m_url),
    m_handler(handler),
    m_curl(nullptr, &curl_easy_cleanup),
    m_logger(logger)
    {}

References m_curl, m_handler, m_header_callout, m_header_expiry, m_logger, m_request_url, and m_url.

~CurlOperation()

CurlOperation::~CurlOperation ( )

virtual

Definition at line 191 of file XrdClHttpOps.cc.

{}

CurlOperation() [3/3]

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

delete

References CurlOperation(), Fail(), FinishSetup(), ReleaseHandle(), and Setup().

Here is the call graph for this function:

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.

{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(), and m_header_expiry.

Here is the call graph for this function:

Fail()

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

virtual

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

Definition at line 205 of file XrdClHttpOps.cc.

{
    SetDone(true);
    if (m_handler == nullptr) {return;}
    if (!msg.empty()) {
        m_logger->Debug(kLogXrdClHttp, "curl operation failed with message: %s", msg.c_str());
    } else {
        m_logger->Debug(kLogXrdClHttp, "curl operation failed with status code %d", errNum);
    }
    auto status = new XrdCl::XRootDStatus(XrdCl::stError, errCode, errNum, msg);
    auto handle = m_handler;
    m_handler = nullptr;
    handle->HandleResponse(status, nullptr);
}

References XrdCl::Log::Debug(), XrdCl::ResponseHandler::HandleResponse(), XrdClHttp::kLogXrdClHttp, m_handler, m_logger, SetDone(), and XrdCl::stError.

Referenced by CurlOperation(), FinishSetup(), Redirect(), XrdClHttp::CurlWorker::Run(), StartConnectionCallout(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlQueryOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

Here is the call graph for this function:

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 XrdCl::Log::Debug(), emsg(), ErrCallback, XrdClHttp::kLogXrdClHttp, and m_logger.

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::Log::Error(), Fail(), XrdCl::DefaultEnv::GetEnv(), XrdClHttp::HeaderCallout::GetHeaders(), GetVerb(), GetVerbString(), XrdClHttp::InjectBearerToken(), XrdClHttp::kLogXrdClHttp, m_header_callout, m_headers_list, m_logger, m_request_url, and m_url.

Referenced by CurlOperation(), 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.

{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.

{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.

{return m_curl.get();}

References m_curl.

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

Here is the caller graph for this function:

GetDefaultSlowRateBytesSec()

int XrdClHttp::CurlOperation::GetDefaultSlowRateBytesSec ( )

inlinestatic

Definition at line 288 of file XrdClHttpOps.hh.

    {
        return m_default_minimum_rate;
    }

References m_default_minimum_rate.

GetDefaultStallTimeout()

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.

{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::CurlOptionsOp::CurlOptionsOp(), XrdClHttp::CurlStatOp::CurlStatOp(), GetOperationExpiry(), HeaderTimeoutExpired(), Redirect(), and StartConnectionCallout().

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

(

)

References HeaderTimeoutExpired(), OperationTimeoutExpired(), and TransferStalled().

Here is the call graph for this function:

GetStatusCode()

int XrdClHttp::CurlOperation::GetStatusCode ( ) const

inline

Definition at line 239 of file XrdClHttpOps.hh.

{return m_headers.GetStatusCode();}

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

Referenced by XrdClHttp::CurlMkcolOp::Fail(), XrdClHttp::CurlTapeOp::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.

{return m_headers.GetStatusMessage();}

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.

{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.

{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::CurlChecksumOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlOptionsOp, XrdClHttp::CurlPgReadOp, XrdClHttp::CurlPutOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlStatOp, XrdClHttp::CurlTapeOp, and XrdClHttp::CurlVectorReadOp.

References GetVerbString().

Referenced by FinishSetup().

Here is the call graph for this function:

Here is the caller graph for this function:

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";
}

References XrdClHttp::COPY, XrdClHttp::Count, XrdClHttp::DELETE, XrdClHttp::GET, XrdClHttp::HEAD, XrdClHttp::MKCOL, XrdClHttp::OPTIONS, XrdClHttp::POST, XrdClHttp::PROPFIND, and XrdClHttp::PUT.

Referenced by FinishSetup(), XrdClHttp::CurlWorker::GetMonitoringJson(), and GetVerb().

Here is the caller graph for this function:

HasFailed()

bool XrdClHttp::CurlOperation::HasFailed ( ) const

inline

Definition at line 251 of file XrdClHttpOps.hh.

{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;
}

References ErrHeaderTimeout, ErrNone, and GetHeaderExpiry().

Referenced by GetResponseInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDone()

bool XrdClHttp::CurlOperation::IsDone ( ) const

inline

Definition at line 245 of file XrdClHttpOps.hh.

{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.

{return m_is_paused;}

Referenced by XrdClHttp::CurlWorker::Run(), StatisticsReset(), and TransferStalled().

Here is the caller graph for this function:

IsRedirect()

bool XrdClHttp::CurlOperation::IsRedirect ( ) const

inline

Definition at line 161 of file XrdClHttpOps.hh.

{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.

{return std::move(m_response_info);}

Referenced by XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlMkcolOp::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;
}

References ErrNone, ErrOperationTimeout, and m_operation_expiry.

Referenced by GetResponseInfo().

Here is the caller graph for this function:

OptionsDone()

virtual void XrdClHttp::CurlOperation::OptionsDone ( )

inlinevirtual

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

Definition at line 184 of file XrdClHttpOps.hh.

{}

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 XrdClHttp::HeaderParser::HeaderParser(), XrdCl::Log::Debug(), XrdCl::errErrorResponse, XrdCl::errInternal, Fail(), Fail, XrdCl::DefaultEnv::GetEnv(), GetHeaderExpiry(), XrdClHttp::HeaderParser::GetLocation(), XrdClHttp::kLogXrdClHttp, kXR_ServerError, m_curl, m_headers, m_logger, m_request_url, Reinvoke, SetTriedBoker(), and XrdCl::Log::Warning().

Referenced by XrdClHttp::CurlChecksumOp::Redirect(), XrdClHttp::CurlStatOp::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::CurlChecksumOp, XrdClHttp::CurlCopyOp, XrdClHttp::CurlDeleteOp, XrdClHttp::CurlListdirOp, XrdClHttp::CurlMkcolOp, XrdClHttp::CurlOpenOp, XrdClHttp::CurlOptionsOp, XrdClHttp::CurlPutOp, XrdClHttp::CurlReadOp, XrdClHttp::CurlStatOp, XrdClHttp::CurlTapeOp, and XrdClHttp::CurlVectorReadOp.

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();
}

References m_curl.

Referenced by CurlOperation(), XrdClHttp::CurlCopyOp::ReleaseHandle(), XrdClHttp::CurlDeleteOp::ReleaseHandle(), XrdClHttp::CurlListdirOp::ReleaseHandle(), XrdClHttp::CurlMkcolOp::ReleaseHandle(), XrdClHttp::CurlOptionsOp::ReleaseHandle(), XrdClHttp::CurlPutOp::ReleaseHandle(), XrdClHttp::CurlReadOp::ReleaseHandle(), XrdClHttp::CurlStatOp::ReleaseHandle(), XrdClHttp::CurlTapeOp::ReleaseHandle(), XrdClHttp::CurlVectorReadOp::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.

{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.

{}

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.

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

Referenced by Fail(), XrdClHttp::CurlPutOp::Fail(), XrdClHttp::CurlReadOp::Fail(), XrdClHttp::CurlVectorReadOp::Fail(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlCopyOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlMkcolOp::Success(), XrdClHttp::CurlOpenOp::Success(), XrdClHttp::CurlPgReadOp::Success(), XrdClHttp::CurlPutOp::Success(), XrdClHttp::CurlQueryOp::Success(), XrdClHttp::CurlReadOp::Success(), XrdClHttp::CurlVectorReadOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

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::CurlPutOp::ContinueHandle(), XrdClHttp::CurlReadOp::ContinueHandle(), XrdClHttp::CurlPutOp::Pause(), and XrdClHttp::CurlReadOp::Pause().

Here is the caller graph for this function:

SetSlowRateBytesSec()

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]

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]

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);
    }

Referenced by XrdClHttp::File::SetProperty().

Here is the caller graph for this function:

SetTriedBoker()

void XrdClHttp::CurlOperation::SetTriedBoker ( )

inline

Definition at line 178 of file XrdClHttpOps.hh.

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

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

Here is the caller graph for this function:

Setup()

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

virtual

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

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(), XrdCl::Log::Debug(), XrdCl::Log::Error(), XrdCl::DefaultEnv::GetEnv(), XrdClHttp::kLogXrdClHttp, m_curl, m_logger, and m_request_url.

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

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::HeaderParser::HeaderParser(), XrdClHttp::ConfigureHandle(), ErrNone, kXR_noErrorYet, m_curl, m_headers, m_headers_list, m_request_url, and Setup().

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, Fail(), and GetHeaderExpiry().

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

Here is the call graph for this function:

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};
}

References IsPaused().

Here is the call graph for this function:

Success()

virtual void XrdClHttp::CurlOperation::Success ( )

pure virtual

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

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;
}

References ErrNone, ErrTransferClientStall, ErrTransferSlow, ErrTransferStall, IsPaused(), and m_minimum_rate.

Referenced by GetResponseInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateBytes()

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

inlineprotected

Definition at line 307 of file XrdClHttpOps.hh.

{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.

{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.

{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;
}

References XrdCl::Log::Debug(), XrdCl::Log::Error(), XrdClHttp::kLogXrdClHttp, and m_logger.

Here is the call graph for this function:

Member Data Documentation

m_curl

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

protected

Definition at line 416 of file XrdClHttpOps.hh.

Referenced by CurlOperation(), XrdClHttp::CurlReadOp::ContinueHandle(), GetCurlHandle(), XrdClHttp::CurlStatOp::OptionsDone(), XrdClHttp::CurlPrefetchOpenOp::Pause(), XrdClHttp::CurlChecksumOp::Redirect(), Redirect(), XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlChecksumOp::ReleaseHandle(), XrdClHttp::CurlCopyOp::ReleaseHandle(), XrdClHttp::CurlDeleteOp::ReleaseHandle(), XrdClHttp::CurlListdirOp::ReleaseHandle(), XrdClHttp::CurlMkcolOp::ReleaseHandle(), XrdClHttp::CurlOpenOp::ReleaseHandle(), ReleaseHandle(), XrdClHttp::CurlOptionsOp::ReleaseHandle(), XrdClHttp::CurlPutOp::ReleaseHandle(), XrdClHttp::CurlReadOp::ReleaseHandle(), XrdClHttp::CurlStatOp::ReleaseHandle(), XrdClHttp::CurlTapeOp::ReleaseHandle(), XrdClHttp::CurlVectorReadOp::ReleaseHandle(), XrdClHttp::CurlChecksumOp::Setup(), XrdClHttp::CurlCopyOp::Setup(), XrdClHttp::CurlDeleteOp::Setup(), XrdClHttp::CurlListdirOp::Setup(), XrdClHttp::CurlMkcolOp::Setup(), Setup(), XrdClHttp::CurlOptionsOp::Setup(), XrdClHttp::CurlPutOp::Setup(), XrdClHttp::CurlReadOp::Setup(), XrdClHttp::CurlStatOp::Setup(), XrdClHttp::CurlTapeOp::Setup(), XrdClHttp::CurlVectorReadOp::Setup(), SetupNextRequest(), and XrdClHttp::CurlTapeOp::Success().

m_default_minimum_rate

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

Definition at line 415 of file XrdClHttpOps.hh.

Referenced by CurlOperation(), XrdClHttp::CurlPutOp::Continue(), XrdClHttp::CurlPutOp::Continue(), XrdClHttp::CurlReadOp::Continue(), Fail(), XrdClHttp::CurlPutOp::Fail(), XrdClHttp::CurlReadOp::Fail(), XrdClHttp::CurlVectorReadOp::Fail(), XrdClHttp::CurlPutOp::Pause(), XrdClHttp::CurlReadOp::Pause(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlCopyOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlMkcolOp::Success(), XrdClHttp::CurlPgReadOp::Success(), XrdClHttp::CurlPutOp::Success(), XrdClHttp::CurlQueryOp::Success(), XrdClHttp::CurlReadOp::Success(), XrdClHttp::CurlVectorReadOp::Success(), and XrdClHttp::CurlStatOp::SuccessImpl().

m_header_callout

HeaderCallout* XrdClHttp::CurlOperation::m_header_callout

protected

Definition at line 339 of file XrdClHttpOps.hh.

Referenced by CurlOperation(), and FinishSetup().

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 CurlOperation(), ExtendDeadline(), and 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(), Redirect(), XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlVectorReadOp::SetSeparator(), XrdClHttp::CurlVectorReadOp::SetStatusCode(), SetupNextRequest(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlOptionsOp::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(), FinishSetup(), XrdClHttp::CurlStatOp::OptionsDone(), XrdClHttp::CurlStatOp::Redirect(), XrdClHttp::CurlChecksumOp::Setup(), XrdClHttp::CurlListdirOp::Setup(), XrdClHttp::CurlReadOp::Setup(), XrdClHttp::CurlStatOp::Setup(), XrdClHttp::CurlVectorReadOp::Setup(), and SetupNextRequest().

m_logger

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

protected

Definition at line 419 of file XrdClHttpOps.hh.

Referenced by CurlOperation(), XrdClHttp::CurlReadOp::Continue(), XrdClHttp::CurlPutOp::ContinueHandle(), XrdClHttp::CurlReadOp::ContinueHandle(), XrdClHttp::CurlMkcolOp::Fail(), XrdClHttp::CurlOpenOp::Fail(), Fail(), XrdClHttp::CurlPutOp::Fail(), XrdClHttp::CurlReadOp::Fail(), XrdClHttp::CurlVectorReadOp::Fail(), FailCallback(), FinishSetup(), XrdClHttp::CurlStatOp::GetStatInfo(), XrdClHttp::CurlPutOp::Pause(), XrdClHttp::CurlReadOp::Pause(), Redirect(), Setup(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlMkcolOp::Success(), XrdClHttp::CurlOpenOp::Success(), XrdClHttp::CurlPutOp::Success(), XrdClHttp::CurlQueryOp::Success(), XrdClHttp::CurlStatOp::SuccessImpl(), and WaitSocketCallback().

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(), XrdClHttp::CurlListdirOp::CurlListdirOp(), and TransferStalled().

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(), and OperationTimeoutExpired().

m_request_url

std::string XrdClHttp::CurlOperation::m_request_url

protected

Definition at line 414 of file XrdClHttpOps.hh.

Referenced by CurlOperation(), FinishSetup(), GetUrl(), Redirect(), Setup(), XrdClHttp::CurlTapeOp::Setup(), and SetupNextRequest().

m_url

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

protected

Definition at line 411 of file XrdClHttpOps.hh.

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

---

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

• XrdClHttpOps.hh
• XrdClHttpOps.cc