XrdClHttp::File Class Reference

#include <XrdClHttpFile.hh>

Inheritance diagram for XrdClHttp::File:

Collaboration diagram for XrdClHttp::File:

Public Member Functions
	File (std::shared_ptr< XrdClHttp::HandlerQueue > queue, XrdCl::Log *log)
virtual	~File () noexcept
virtual XrdCl::XRootDStatus	Close (XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	Fcntl (const XrdCl::Buffer &arg, XrdCl::ResponseHandler *handler, time_t timeout) override
XrdCl::OpenFlags::Flags	Flags () const
struct timespec	GetHeaderTimeout (time_t oper_timeout) const
virtual bool	GetProperty (const std::string &name, std::string &value) const override
virtual bool	IsOpen () const override
virtual XrdCl::XRootDStatus	Open (const std::string &url, XrdCl::OpenFlags::Flags flags, XrdCl::Access::Mode mode, XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	PgRead (uint64_t offset, uint32_t size, void *buffer, XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	Read (uint64_t offset, uint32_t size, void *buffer, XrdCl::ResponseHandler *handler, time_t timeout) override
void	SetHeaderTimeout (const struct timespec &ts)
virtual bool	SetProperty (const std::string &name, const std::string &value) override
virtual XrdCl::XRootDStatus	Stat (bool force, XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	VectorRead (const XrdCl::ChunkList &chunks, void *buffer, XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	Write (uint64_t offset, uint32_t size, const void *buffer, XrdCl::ResponseHandler *handler, time_t timeout) override
virtual XrdCl::XRootDStatus	Write (uint64_t offset, XrdCl::Buffer &&buffer, XrdCl::ResponseHandler *handler, time_t timeout) override
Public Member Functions inherited from XrdCl::FilePlugIn
virtual	~FilePlugIn ()
	Destructor.
virtual XRootDStatus	Clone (const CloneLocations &locs, ResponseHandler *handler, time_t timeout)
virtual std::unique_ptr< ExportedFileTemplate >	ExportTemplate () const
virtual XRootDStatus	Fcntl (QueryCode::Code queryCode, const Buffer &arg, ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	OpenUsingTemplate (ExportedFileTemplate *templ, const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	PgWrite (uint64_t offset, uint32_t nbpgs, const void *buffer, std::vector< uint32_t > &cksums, ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	PreRead (const TractList &tracts, ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	Read (uint64_t offset, uint32_t size, Optional< uint64_t > fdoff, int fd, ResponseHandler *handler, time_t timeout=0)
virtual XRootDStatus	Sync (ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	Truncate (uint64_t size, ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	VectorWrite (const ChunkList &chunks, ResponseHandler *handler, time_t timeout=0)
virtual XRootDStatus	Visa (ResponseHandler *handler, time_t timeout)
virtual XRootDStatus	Write (uint64_t offset, uint32_t size, Optional< uint64_t > fdoff, int fd, ResponseHandler *handler, time_t timeout=0)
virtual XRootDStatus	WriteV (uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)

Static Public Member Functions
static const struct timespec &	GetDefaultHeaderTimeout ()
static struct timespec	GetFederationMetadataTimeout ()
static struct timespec	GetHeaderTimeoutWithDefault (time_t oper_timeout, const struct timespec &header_timeout)
static const struct timespec &	GetMinimumHeaderTimeout ()
static std::string	GetMonitoringJson ()
static struct timespec	ParseHeaderTimeout (const std::string &header_value, XrdCl::Log *logger)
static void	SetDefaultHeaderTimeout (struct timespec &ts)
static void	SetFederationMetadataTimeout (const struct timespec &ts)
static void	SetMinimumHeaderTimeout (struct timespec &ts)

Detailed Description

Definition at line 43 of file XrdClHttpFile.hh.

Constructor & Destructor Documentation

File()

XrdClHttp::File::File ( std::shared_ptr< XrdClHttp::HandlerQueue > queue, XrdCl::Log * log )

inline

Definition at line 45 of file XrdClHttpFile.hh.

                                                                    :
        m_queue(queue),
        m_logger(log),
        m_default_put_handler(new PutDefaultHandler(*this))
    {}

Referenced by GetHeaderTimeout(), GetHeaderTimeoutWithDefault(), and ParseHeaderTimeout().

Here is the caller graph for this function:

~File()

File::~File ( )

virtualnoexcept

Definition at line 202 of file XrdClHttpFile.cc.

                     {
    auto handler = m_put_handler.load(std::memory_order_acquire);
    if (handler) {
        // We must wait for all ongoing writes to complete; the XrdCl::File
        // destructor will trigger a Close() operation when it is called without
        // waiting for the Close to finish, then invoke our destructor.
        // If the Close() is still ongoing, then the handler will receive a
        // callback after its memory is freed.
        handler->WaitForCompletion();
        delete handler;
    }
}

References ~File().

Referenced by ~File().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

Close()

XrdCl::XRootDStatus File::Close ( XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Close

Reimplemented from XrdCl::FilePlugIn.

Definition at line 410 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot close.  URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    m_is_opened = false;
 
    std::unique_ptr<XrdCl::XRootDStatus> status(new XrdCl::XRootDStatus{});
    if (m_put_op && !m_put_op->HasFailed()) {
        auto put_size = m_put_offset.load(std::memory_order_relaxed);
        if (m_asize >= 0 && put_size == m_asize) {
            if (put_size == m_asize) {
                m_logger->Debug(kLogXrdClHttp, "Closing a finished file %s", m_url.c_str());
            } else {
                m_logger->Debug(kLogXrdClHttp, "Closing a file %s with partial size (offset %llu, expected %lld)",
                                m_url.c_str(), static_cast<unsigned long long>(put_size), static_cast<long long>(m_asize));
                status.reset(new XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp,
                    0, "Cannot close file with partial size"));
            }
        } else {
            m_logger->Debug(kLogXrdClHttp, "Flushing final write buffer on close");
            auto put_handler = m_put_handler.load(std::memory_order_acquire);
            if (put_handler) {
                return put_handler->QueueWrite(std::make_pair(nullptr, 0), handler);
            } else {
                m_logger->Error(kLogXrdClHttp, "Internal state error - put operation ongoing without handle");
                return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
            }
        }
    } else if (!m_put_op && m_open_flags & XrdCl::OpenFlags::Write) {
        timespec ts;
        timespec_get(&ts, TIME_UTC);
        ts.tv_sec += timeout;
        m_asize = 0;
        auto handler_wrapper = new PutResponseHandler(new CloseCreateHandler(handler));
        m_put_handler.store(handler_wrapper, std::memory_order_release);
        m_put_op.reset(new XrdClHttp::CurlPutOp(
            handler_wrapper, m_default_put_handler, m_url, nullptr, 0, ts, m_logger,
            GetConnCallout(), &m_default_header_callout
        ));
        handler_wrapper->SetOp(m_put_op);
        m_url_current = "";
        m_last_url = "";
        m_logger->Debug(kLogXrdClHttp, "Creating a zero-sized object at %s for close", m_url.c_str());
        try {
            m_queue->Produce(m_put_op);
        } catch (...) {
            m_put_handler.store(nullptr, std::memory_order_release);
            m_logger->Warning(kLogXrdClHttp, "Failed to add put op to queue");
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
        }
        return {};
    }
 
    m_logger->Debug(kLogXrdClHttp, "Closed %s", m_url.c_str());
    m_url_current = "";
    m_last_url = "";
 
    if (handler) {
        handler->HandleResponse(status.release(), nullptr);
    }
    return XrdCl::XRootDStatus();
}

References XrdCl::errInvalidOp, XrdCl::errOSError, XrdCl::ResponseHandler::HandleResponse(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, ts(), and XrdCl::OpenFlags::Write.

Here is the call graph for this function:

Fcntl()

XrdCl::XRootDStatus File::Fcntl ( const XrdCl::Buffer & arg, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Fcntl

Reimplemented from XrdCl::FilePlugIn.

Definition at line 514 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot run fcntl.  URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
 
    auto obj = new XrdCl::AnyObject();
    std::string as = arg.ToString();
    try
    {
        XrdCl::QueryCode::Code code = (XrdCl::QueryCode::Code)std::stoi(as);
        if (code == XrdCl::QueryCode::XAttr)
        {
            nlohmann::json xatt;
            std::string etagRes;
            if (GetProperty("ETag", etagRes))
            {
                xatt["ETag"] = etagRes;
            }
            std::string cc;
            if (GetProperty("Cache-Control", cc))
            {
                if (cc.find("must-revalidate") != std::string::npos)
                {
                    xatt["revalidate"] = true;
                }
                size_t fm = cc.find("max-age=");
                if (fm != std::string::npos)
                {
                    fm += 9; // idx of the first character after the make-age= match
                    for (size_t i = fm; i < cc.length(); i++)
                    {
                        if (!std::isdigit(cc[i]))
                        {
                            std::string sa = cc.substr(fm, i);
                            long int a = std::stol(sa);
                            time_t t = time(NULL) + a;
                            xatt["expire"] = t;
                            break;
                        }
                    }
                }
            }
            XrdCl::Buffer *respBuff = new XrdCl::Buffer();
            m_logger->Debug(kLogXrdClHttp, "Fcntl content %s", xatt.dump().c_str());
            respBuff->FromString(xatt.dump());
            obj->Set(respBuff);
        }
        //
        //   Query codes supported by  XrdCl::File::Fctnl
        //
        else {
            std::string msg;
            XrdCl::XRootDStatus status = XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
            switch (code) {
            case XrdCl::QueryCode::Stats:
                msg = "Server status query not supported.";
                break;
            case XrdCl::QueryCode::Checksum: // fallthrough
            case XrdCl::QueryCode::ChecksumCancel:
                msg = "Checksum query not supported.";
                break;
            case XrdCl::QueryCode::Config:
                msg = "Server configuration query not supported.";
                break;
            case XrdCl::QueryCode::Space:
                msg = "Local space stats query not supported.";
                break;
            case XrdCl::QueryCode::Opaque: // fallthrough
            case XrdCl::QueryCode::OpaqueFile:
                // XrdCl implementation dependent
                msg = "Opaque query not supported.";
                break;
            case XrdCl::QueryCode::Prepare:
                msg = "Prepare status query not supported.";
                break;
            default:
                msg = "Invalid information query type code";
            }
            m_logger->Error(kLogXrdClHttp, "%s", msg.c_str());
            return status;
        }
    }
    catch (const std::exception& e)
    {
        m_logger->Warning(kLogXrdClHttp, "Failed to parse query code %s", e.what());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errDataError);
    }
 
    handler->HandleResponse(new XrdCl::XRootDStatus(), obj);
    return XrdCl::XRootDStatus();
}

References XrdCl::QueryCode::Checksum, XrdCl::QueryCode::ChecksumCancel, XrdCl::QueryCode::Config, XrdCl::errDataError, XrdCl::errInvalidOp, XrdCl::Buffer::FromString(), GetProperty(), XrdCl::ResponseHandler::HandleResponse(), XrdClHttp::kLogXrdClHttp, XrdCl::QueryCode::Opaque, XrdCl::QueryCode::OpaqueFile, XrdCl::QueryCode::Prepare, XrdCl::QueryCode::Space, XrdCl::QueryCode::Stats, XrdCl::stError, XrdCl::Buffer::ToString(), and XrdCl::QueryCode::XAttr.

Here is the call graph for this function:

Flags()

XrdCl::OpenFlags::Flags XrdClHttp::File::Flags ( ) const

inline

Definition at line 107 of file XrdClHttpFile.hh.

{return m_open_flags;}

References Flags().

Referenced by Flags().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDefaultHeaderTimeout()

const struct timespec & XrdClHttp::File::GetDefaultHeaderTimeout ( )

inlinestatic

Definition at line 119 of file XrdClHttpFile.hh.

{return m_default_header_timeout;}

Referenced by ParseHeaderTimeout().

Here is the caller graph for this function:

GetFederationMetadataTimeout()

struct timespec XrdClHttp::File::GetFederationMetadataTimeout ( )

inlinestatic

Definition at line 137 of file XrdClHttpFile.hh.

{return m_fed_timeout;}

References GetFederationMetadataTimeout().

Referenced by GetFederationMetadataTimeout().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHeaderTimeout()

struct timespec File::GetHeaderTimeout

(

time_t

oper_timeout

)

const

Definition at line 282 of file XrdClHttpFile.cc.

{
    return GetHeaderTimeoutWithDefault(oper_timeout, m_header_timeout);
}

References File(), GetHeaderTimeout(), and GetHeaderTimeoutWithDefault().

Referenced by GetHeaderTimeout(), Open(), PgRead(), Read(), VectorRead(), Write(), and Write().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHeaderTimeoutWithDefault()

struct timespec File::GetHeaderTimeoutWithDefault ( time_t oper_timeout, const struct timespec & header_timeout )

static

Definition at line 262 of file XrdClHttpFile.cc.

{
    if (oper_timeout == 0) {
        int val = XrdCl::DefaultRequestTimeout;
        XrdCl::DefaultEnv::GetEnv()->GetInt( "RequestTimeout", val );
        oper_timeout = val;
    }
    if (oper_timeout <= 0) {
        return header_timeout;
    }
    if (oper_timeout == header_timeout.tv_sec) {
        return {header_timeout.tv_sec, 0};
    } else if (header_timeout.tv_sec < oper_timeout) {
        return header_timeout;
    } else { // header timeout is larger than the operation timeout
        return {oper_timeout, 0};
    }
}

References File(), XrdCl::DefaultRequestTimeout, XrdCl::DefaultEnv::GetEnv(), GetHeaderTimeoutWithDefault(), and XrdCl::Env::GetInt().

Referenced by GetHeaderTimeout(), and GetHeaderTimeoutWithDefault().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMinimumHeaderTimeout()

const struct timespec & XrdClHttp::File::GetMinimumHeaderTimeout ( )

inlinestatic

Definition at line 113 of file XrdClHttpFile.hh.

{return m_min_client_timeout;}

Referenced by ParseHeaderTimeout().

Here is the caller graph for this function:

GetMonitoringJson()

std::string File::GetMonitoringJson ( )

static

Definition at line 288 of file XrdClHttpFile.cc.

{
    return "{\"prefetch\": {"
        "\"count\": " + std::to_string(m_prefetch_count) + ","
        "\"expired\": " + std::to_string(m_prefetch_expired_count) + ","
        "\"failed\": " + std::to_string(m_prefetch_failed_count) + ","
        "\"reads_hit\": " + std::to_string(m_prefetch_reads_hit) + ","
        "\"reads_miss\": " + std::to_string(m_prefetch_reads_miss) + ","
        "\"bytes_used\": " + std::to_string(m_prefetch_bytes_used) +
    "}}";
}

GetProperty()

bool File::GetProperty ( const std::string & name, std::string & value ) const

overridevirtual

See also

XrdCl::File::GetProperty

Reimplemented from XrdCl::FilePlugIn.

Definition at line 985 of file XrdClHttpFile.cc.

{
    if (name == "CurrentURL") {
        value = GetCurrentURL();
        return true;
    }
 
    if (name == "IsPrefetching") {
        value = m_default_prefetch_handler->IsPrefetching() ? "true" : "false";
        return true;
    }
 
    std::shared_lock lock(m_properties_mutex);
    if (name == "LastURL") {
        value = m_last_url;
        return true;
    }
 
    const auto p = m_properties.find(name);
    if (p == std::end(m_properties)) {
        return false;
    }
 
    value = p->second;
    return true;
}

Referenced by Fcntl(), and Stat().

Here is the caller graph for this function:

IsOpen()

bool File::IsOpen ( ) const

overridevirtual

See also

XrdCl::File::IsOpen

Reimplemented from XrdCl::FilePlugIn.

Definition at line 979 of file XrdClHttpFile.cc.

{
    return m_is_opened;
}

Open()

XrdCl::XRootDStatus File::Open ( const std::string & url, XrdCl::OpenFlags::Flags flags, XrdCl::Access::Mode mode, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Open

Reimplemented from XrdCl::FilePlugIn.

Definition at line 301 of file XrdClHttpFile.cc.

{
    if (m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "URL %s already open", url.c_str());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
 
    // Note: workaround for a design flaw of the XrdCl API.
    //
    // Any properties we set on the file *prior* to opening it are sent to the
    // XrdCl base implementation, not the plugin object.  Hence, they are effectively
    // ignored because the later `GetProperty` accesses a different object.  We want
    // the SetProperty calls to take effect because they are needed for successfully
    // `Open`ing the file.  There's no way to "setup the plugin", "set properties", and
    // then "open file" because the first and third operations are part of the same API
    // call.  We thus allow the caller to trigger the plugin loading by doing a special
    // `Open` call (flags set to Compress, access mode None) that is a no-op.
    //
    // Contrast the XrdCl::File plugin loading style with XrdCl::Filesystem; the latter
    // gets a target URL on construction, before any operations are done, allowing
    // the `SetProperty` to work.
    if ((flags == XrdCl::OpenFlags::Compress) && (mode == XrdCl::Access::None) &&
        (handler == nullptr) && (timeout == 0))
    {
        return XrdCl::XRootDStatus();
    }
 
    m_open_flags = flags;
 
    m_header_timeout.tv_nsec = m_default_header_timeout.tv_nsec;
    m_header_timeout.tv_sec = m_default_header_timeout.tv_sec;
    auto parsed_url = XrdCl::URL();
    parsed_url.SetPort(0);
    if (!parsed_url.FromString(url)) {
        m_logger->Error(kLogXrdClHttp, "Failed to parse provided URL as a valid URL: %s", url.c_str());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidArgs);
    }
    auto pm = parsed_url.GetParams();
    auto iter = pm.find("xrdclhttp.timeout");
    std::string timeout_string = (iter == pm.end()) ? "" : iter->second;
    m_header_timeout = ParseHeaderTimeout(timeout_string, m_logger);
    pm["xrdclhttp.timeout"] = XrdClHttp::MarshalDuration(m_header_timeout);
    parsed_url.SetParams(pm);
    iter = pm.find("oss.asize");
    if (iter != pm.end()) {
        off_t asize;
        auto ec = std::from_chars(iter->second.c_str(), iter->second.c_str() + iter->second.size(), asize);
        if ((ec.ec == std::errc()) && (ec.ptr == iter->second.c_str() + iter->second.size()) && asize >= 0) {
            m_asize = asize;
        } else {
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp, 0, "Unable to parse oss.asize to a valid size");
        }
        pm.erase(iter);
        parsed_url.SetParams(pm);
    }
 
    m_url = parsed_url.GetURL();
    m_last_url = "";
    m_url_current = "";
 
    auto ts = GetHeaderTimeout(timeout);
 
    bool full_download = m_full_download.load(std::memory_order_relaxed);
    m_default_prefetch_handler.reset(new PrefetchDefaultHandler(*this));
    if (full_download) {
        m_default_prefetch_handler->m_prefetch_enabled.store(true, std::memory_order_relaxed);
    }
 
    if (full_download && !(flags & XrdCl::OpenFlags::Write)) {
        m_logger->Debug(kLogXrdClHttp, "Opening %s in full download mode", m_url.c_str());
 
        handler = new OpenFullDownloadResponseHandler(&m_is_opened, SendResponseInfo(), handler);
        m_prefetch_size = std::numeric_limits<off_t>::max();
        auto [status, ok] = ReadPrefetch(0, 0, nullptr, handler, timeout, false);
        if (ok) {
            return status;
        } else {
            m_logger->Error(kLogXrdClHttp, "Failed to start prefetch of data at open (URL %s): %s", m_url.c_str(), status.ToString().c_str());
            return status;
        }
    }
 
 
    m_logger->Debug(kLogXrdClHttp, "Opening %s (with timeout %lld)", m_url.c_str(), (long long) timeout);
 
    // This response handler sets the m_is_opened flag to true if the open callback is successfully invoked.
    handler = new OpenResponseHandler(&m_is_opened, handler);
 
    std::shared_ptr<XrdClHttp::CurlOpenOp> openOp(
        new XrdClHttp::CurlOpenOp(
            handler, GetCurrentURL(), ts, m_logger, this, SendResponseInfo(), GetConnCallout(),
            &m_default_header_callout
        )
    );
    try {
        m_queue->Produce(std::move(openOp));
    } catch (...) {
        m_logger->Warning(kLogXrdClHttp, "Failed to add open op to queue");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
    }
 
    return XrdCl::XRootDStatus();
}

References XrdCl::OpenFlags::Compress, ec, XrdCl::errInvalidArgs, XrdCl::errInvalidOp, XrdCl::errOSError, GetHeaderTimeout(), XrdClHttp::kLogXrdClHttp, XrdClHttp::MarshalDuration(), XrdCl::Access::None, ParseHeaderTimeout(), XrdCl::stError, XrdCl::Status::ToString(), ts(), and XrdCl::OpenFlags::Write.

Here is the call graph for this function:

ParseHeaderTimeout()

struct timespec File::ParseHeaderTimeout ( const std::string & header_value, XrdCl::Log * logger )

static

Definition at line 234 of file XrdClHttpFile.cc.

{
    struct timespec ts = File::GetDefaultHeaderTimeout();
    if (!timeout_string.empty()) {
        std::string errmsg;
        // Parse the provided timeout and decrease by a second if we can (if it's below a second, halve it).
        // The thinking is that if the client needs a response in N seconds, then we ought to set the internal
        // timeout to (N-1) seconds to provide enough time for our response to arrive at the client.
        if (!XrdClHttp::ParseTimeout(timeout_string, ts, errmsg)) {
            logger->Error(kLogXrdClHttp, "Failed to parse xrdclhttp.timeout parameter: %s", errmsg.c_str());
        } else if (ts.tv_sec >= 1) {
                ts.tv_sec--;
        } else {
            ts.tv_nsec /= 2;
        }
    }
    const auto mct = File::GetMinimumHeaderTimeout();
    if (ts.tv_sec < mct.tv_sec ||
        (ts.tv_sec == mct.tv_sec && ts.tv_nsec < mct.tv_nsec))
    {
        ts.tv_sec = mct.tv_sec;
        ts.tv_nsec = mct.tv_nsec;
    }
 
    return ts;
}

References File(), GetDefaultHeaderTimeout(), GetMinimumHeaderTimeout(), XrdClHttp::kLogXrdClHttp, ParseHeaderTimeout(), XrdClHttp::ParseTimeout(), and ts().

Referenced by Open(), and ParseHeaderTimeout().

Here is the call graph for this function:

Here is the caller graph for this function:

PgRead()

XrdCl::XRootDStatus File::PgRead ( uint64_t offset, uint32_t size, void * buffer, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl:File PgRead

Reimplemented from XrdCl::FilePlugIn.

Definition at line 934 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot pgread.  URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    auto [status, ok] = ReadPrefetch(offset, size, buffer, handler, timeout, true);
    if (ok) {
        if (status.IsOK()) {
            m_logger->Debug(kLogXrdClHttp, "PgRead %s (%d bytes at offset %lld) will be served from prefetch handler", m_url.c_str(), size, static_cast<long long>(offset));
        } else {
            m_logger->Warning(kLogXrdClHttp, "PgRead %s (%d bytes at offset %lld) failed: %s", m_url.c_str(), size, static_cast<long long>(offset), status.GetErrorMessage().c_str());
        }
        return status;
    } else if (m_full_download.load(std::memory_order_relaxed)) {
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp, 0, "Non-sequential read detected when in full-download mode");
    }
 
    auto ts = GetHeaderTimeout(timeout);
    auto url = GetCurrentURL();
    m_logger->Debug(kLogXrdClHttp, "PgRead %s (%d bytes at offset %lld)", url.c_str(), size, static_cast<long long>(offset));
 
    std::shared_ptr<XrdClHttp::CurlPgReadOp> readOp(
        new XrdClHttp::CurlPgReadOp(
            handler, m_default_prefetch_handler, url, ts, std::make_pair(offset, size),
            static_cast<char*>(buffer), size, m_logger,
            GetConnCallout(), &m_default_header_callout
        )
    );
 
    try {
        m_queue->Produce(std::move(readOp));
    } catch (...) {
        m_logger->Warning(kLogXrdClHttp, "Failed to add read op to queue");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
    }
 
    return XrdCl::XRootDStatus();
}

References XrdCl::errInvalidOp, XrdCl::errOSError, XrdCl::XRootDStatus::GetErrorMessage(), GetHeaderTimeout(), XrdCl::Status::IsOK(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, and ts().

Here is the call graph for this function:

Read()

XrdCl::XRootDStatus File::Read ( uint64_t offset, uint32_t size, void * buffer, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Read

Reimplemented from XrdCl::FilePlugIn.

Definition at line 610 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot read.  URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    auto [status, ok] = ReadPrefetch(offset, size, buffer, handler, timeout, false);
    if (ok) {
        if (status.IsOK()) {
            m_logger->Debug(kLogXrdClHttp, "Read %s (%d bytes at offset %lld) will be served from prefetch handler", m_url.c_str(), size, static_cast<long long>(offset));
        } else {
            m_logger->Warning(kLogXrdClHttp, "Read %s (%d bytes at offset %lld) failed: %s", m_url.c_str(), size, static_cast<long long>(offset), status.GetErrorMessage().c_str());
        }
        return status;
    } else if (m_full_download.load(std::memory_order_relaxed)) {
        std::unique_lock lock(m_default_prefetch_handler->m_prefetch_mutex);
        if (m_prefetch_op && m_prefetch_op->IsDone() && (static_cast<off_t>(offset) == m_prefetch_offset.load(std::memory_order_acquire))) {
            if (handler) {
                auto ci = new XrdCl::ChunkInfo(offset, 0, buffer);
                auto obj = new XrdCl::AnyObject();
                obj->Set(ci);
                handler->HandleResponse(new XrdCl::XRootDStatus{}, obj);
            }
            return XrdCl::XRootDStatus{};
        }
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp, 0, "Non-sequential read detected when in full-download mode");
    }
 
    auto ts = GetHeaderTimeout(timeout);
    auto url = GetCurrentURL();
    m_logger->Debug(kLogXrdClHttp, "Read %s (%d bytes at offset %lld with timeout %lld)", url.c_str(), size, static_cast<long long>(offset), static_cast<long long>(ts.tv_sec));
 
    std::shared_ptr<XrdClHttp::CurlReadOp> readOp(
        new XrdClHttp::CurlReadOp(
            handler, m_default_prefetch_handler, url, ts, std::make_pair(offset, size),
            static_cast<char*>(buffer), size, m_logger,
           GetConnCallout(), &m_default_header_callout
        )
    );
    try {
        m_queue->Produce(std::move(readOp));
    } catch (...) {
        m_logger->Warning(kLogXrdClHttp, "Failed to add read op to queue");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
    }
 
    return XrdCl::XRootDStatus();
}

References XrdCl::errInvalidOp, XrdCl::errOSError, XrdCl::XRootDStatus::GetErrorMessage(), GetHeaderTimeout(), XrdCl::ResponseHandler::HandleResponse(), XrdCl::Status::IsOK(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, and ts().

Here is the call graph for this function:

SetDefaultHeaderTimeout()

void XrdClHttp::File::SetDefaultHeaderTimeout ( struct timespec & ts )

inlinestatic

Definition at line 116 of file XrdClHttpFile.hh.

{m_default_header_timeout.tv_sec = ts.tv_sec; m_default_header_timeout.tv_nsec = ts.tv_nsec;}

References ts().

Here is the call graph for this function:

SetFederationMetadataTimeout()

void XrdClHttp::File::SetFederationMetadataTimeout ( const struct timespec & ts )

inlinestatic

Definition at line 134 of file XrdClHttpFile.hh.

{m_fed_timeout.tv_sec = ts.tv_sec; m_fed_timeout.tv_nsec = ts.tv_nsec;}

References SetFederationMetadataTimeout(), and ts().

Referenced by SetFederationMetadataTimeout().

Here is the call graph for this function:

Here is the caller graph for this function:

SetHeaderTimeout()

void XrdClHttp::File::SetHeaderTimeout ( const struct timespec & ts )

inline

Definition at line 122 of file XrdClHttpFile.hh.

{m_header_timeout.tv_sec = ts.tv_sec; m_header_timeout.tv_nsec = ts.tv_nsec;}

References ts().

Here is the call graph for this function:

SetMinimumHeaderTimeout()

void XrdClHttp::File::SetMinimumHeaderTimeout ( struct timespec & ts )

inlinestatic

Definition at line 110 of file XrdClHttpFile.hh.

{m_min_client_timeout.tv_sec = ts.tv_sec; m_min_client_timeout.tv_nsec = ts.tv_nsec;}

References ts().

Here is the call graph for this function:

SetProperty()

bool File::SetProperty ( const std::string & name, const std::string & value )

overridevirtual

See also

XrdCl::File::SetProperty

Reimplemented from XrdCl::FilePlugIn.

Definition at line 1019 of file XrdClHttpFile.cc.

{
    if (name == "XrdClHttpHeaderCallout") {
        long long pointer;
        try {
            pointer = std::stoll(value, nullptr, 16);
        } catch (...) {
            pointer = 0;
        }
        m_header_callout.store(reinterpret_cast<XrdClHttp::HeaderCallout*>(pointer), std::memory_order_release);
    } else if (name == "XrdClHttpFullDownload") {
        if (value == "true") {
            auto prefetch_handler = m_default_prefetch_handler;
            if (prefetch_handler) {
                std::unique_lock lock(prefetch_handler->m_prefetch_mutex);
                prefetch_handler->m_prefetch_enabled.store(true, std::memory_order_relaxed);
            }
            m_full_download.store(true, std::memory_order_relaxed);
        }
    }
 
    std::unique_lock lock(m_properties_mutex);
 
    m_properties[name] = value;
    if (name == "LastURL") {
        m_last_url = value;
        m_url_current = "";
    }
    else if (name == "XrdClHttpQueryParam") {
        CalculateCurrentURL(value);
    }
    else if (name == "XrdClHttpMaintenancePeriod") {
        unsigned period;
        auto ec = std::from_chars(value.c_str(), value.c_str() + value.size(), period);
        if ((ec.ec == std::errc()) && (ec.ptr == value.c_str() + value.size()) && period > 0) {
            m_logger->Debug(kLogXrdClHttp, "Setting maintenance period to %u", period);
            CurlWorker::SetMaintenancePeriod(period);
        }
    }
    else if (name == "XrdClHttpStallTimeout") {
        std::string errmsg;
        timespec ts;
        if (!ParseTimeout(value, ts, errmsg)) {
            m_logger->Debug(kLogXrdClHttp, "Failed to parse timeout value (%s): %s", value.c_str(), errmsg.c_str());
        } else {
            CurlOperation::SetStallTimeout(std::chrono::seconds{ts.tv_sec} + std::chrono::nanoseconds{ts.tv_nsec});
        }
    }
    else if (name == "XrdClHttpPrefetchSize") {
        off_t size;
        auto ec = std::from_chars(value.c_str(), value.c_str() + value.size(), size);
        if ((ec.ec == std::errc()) && (ec.ptr == value.c_str() + value.size())) {
            lock.unlock();
            std::unique_lock lock2(m_default_prefetch_handler->m_prefetch_mutex);
            m_prefetch_size = size;
        } else {
            m_logger->Debug(kLogXrdClHttp, "XrdClHttpPrefetchSize value (%s) was not parseable", value.c_str());
        }
    }
    return true;
}

References ec, XrdClHttp::kLogXrdClHttp, XrdClHttp::ParseTimeout(), XrdClHttp::CurlWorker::SetMaintenancePeriod(), XrdClHttp::CurlOperation::SetStallTimeout(), and ts().

Here is the call graph for this function:

Stat()

XrdCl::XRootDStatus File::Stat ( bool force, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Stat

Reimplemented from XrdCl::FilePlugIn.

Definition at line 477 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot stat.  URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
 
    std::string content_length_str;
    int64_t content_length;
    if (!GetProperty("ContentLength", content_length_str)) {
        m_logger->Error(kLogXrdClHttp, "Content length missing for %s", m_url.c_str());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    try {
        content_length = std::stoll(content_length_str);
    } catch (...) {
        m_logger->Error(kLogXrdClHttp, "Content length not an integer for %s", m_url.c_str());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    if (content_length < 0) {
        m_logger->Error(kLogXrdClHttp, "Content length negative for %s", m_url.c_str());
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidResponse);
    }
 
    m_logger->Debug(kLogXrdClHttp, "Successful stat operation on %s (size %lld)", m_url.c_str(), static_cast<long long>(content_length));
    auto stat_info = new XrdCl::StatInfo("nobody", content_length,
        XrdCl::StatInfo::Flags::IsReadable, time(NULL));
    auto obj = new XrdCl::AnyObject();
    obj->Set(stat_info);
 
    handler->HandleResponse(new XrdCl::XRootDStatus(), obj);
    return XrdCl::XRootDStatus();
}

References XrdCl::errInvalidOp, XrdCl::errInvalidResponse, GetProperty(), XrdCl::ResponseHandler::HandleResponse(), XrdCl::StatInfo::IsReadable, XrdClHttp::kLogXrdClHttp, and XrdCl::stError.

Here is the call graph for this function:

VectorRead()

XrdCl::XRootDStatus File::VectorRead ( const XrdCl::ChunkList & chunks, void * buffer, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::VectorRead

Reimplemented from XrdCl::FilePlugIn.

Definition at line 773 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot do vector read: URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    } else if (m_full_download.load(std::memory_order_relaxed)) {
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp, 0, "Only sequential reads are supported when in full-download mode");
    }
    if (chunks.empty()) {
        if (handler) {
            auto status = new XrdCl::XRootDStatus();
            auto vr = std::make_unique<XrdCl::VectorReadInfo>();
            vr->SetSize(0);
            auto obj = new XrdCl::AnyObject();
            obj->Set(vr.release());
            handler->HandleResponse(status, obj);
        }
        return XrdCl::XRootDStatus();
    }
 
    auto ts = GetHeaderTimeout(timeout);
    auto url = GetCurrentURL();
    m_logger->Debug(kLogXrdClHttp, "Read %s (%lld chunks; first chunk is %u bytes at offset %lld with timeout %lld)", url.c_str(), static_cast<long long>(chunks.size()), static_cast<unsigned>(chunks[0].GetLength()), static_cast<long long>(chunks[0].GetOffset()), static_cast<long long>(ts.tv_sec));
 
    std::shared_ptr<XrdClHttp::CurlVectorReadOp> readOp(
        new XrdClHttp::CurlVectorReadOp(
            handler, url, ts, chunks, m_logger, GetConnCallout(), &m_default_header_callout
        )
    );
    try {
        m_queue->Produce(std::move(readOp));
    } catch (...) {
        m_logger->Warning(kLogXrdClHttp, "Failed to add vector read op to queue");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
    }
 
    return XrdCl::XRootDStatus();
}

References XrdCl::errInvalidOp, XrdCl::errOSError, GetHeaderTimeout(), XrdCl::ResponseHandler::HandleResponse(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, and ts().

Here is the call graph for this function:

Write() [1/2]

XrdCl::XRootDStatus File::Write ( uint64_t offset, uint32_t size, const void * buffer, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Write

Reimplemented from XrdCl::FilePlugIn.

Definition at line 816 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot write: URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    } else if (m_full_download.load(std::memory_order_relaxed)) {
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp, 0, "Only sequential reads are supported when in full-download mode");
    }
    m_default_prefetch_handler->DisablePrefetch();
 
    auto ts = GetHeaderTimeout(timeout);
    auto url = GetCurrentURL();
    m_logger->Debug(kLogXrdClHttp, "Write %s (%d bytes at offset %lld with timeout %lld)", url.c_str(), size, static_cast<long long>(offset), static_cast<long long>(ts.tv_sec));
 
    auto handler_wrapper = m_put_handler.load(std::memory_order_relaxed);
    if (!handler_wrapper) {
        handler_wrapper = new PutResponseHandler(handler);
        PutResponseHandler *expected_value = nullptr;
        if (!m_put_handler.compare_exchange_strong(expected_value, handler_wrapper, std::memory_order_acq_rel)) {
            delete handler_wrapper;
            return expected_value->QueueWrite(std::make_pair(buffer, size), handler);
        }
 
        if (offset != 0) {
            m_put_handler.store(nullptr, std::memory_order_release);
            delete handler_wrapper;
            m_logger->Warning(kLogXrdClHttp, "Cannot start PUT operation at non-zero offset");
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidArgs, 0, "HTTP uploads must start at offset 0");
        }
        m_put_op.reset(new XrdClHttp::CurlPutOp(
            handler_wrapper, m_default_put_handler, url, static_cast<const char*>(buffer), size, ts, m_logger,
            GetConnCallout(), &m_default_header_callout
        ));
        handler_wrapper->SetOp(m_put_op);
        m_put_offset.fetch_add(size, std::memory_order_acq_rel);
        try {
            m_queue->Produce(m_put_op);
        } catch (...) {
            m_put_handler.store(nullptr, std::memory_order_release);
            delete handler_wrapper;
            m_logger->Warning(kLogXrdClHttp, "Failed to add put op to queue");
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
        }
        return XrdCl::XRootDStatus();
    }
 
    auto old_offset = m_put_offset.fetch_add(size, std::memory_order_acq_rel);
    if (static_cast<off_t>(offset) != old_offset) {
        m_put_offset.fetch_sub(size, std::memory_order_acq_rel);
        m_logger->Warning(kLogXrdClHttp, "Requested write offset at %lld does not match current file descriptor offset at %lld",
            static_cast<long long>(offset), static_cast<long long>(old_offset));
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidArgs, 0, "Requested write offset does not match current offset");
    }
    return handler_wrapper->QueueWrite(std::make_pair(buffer, size), handler);
}

References XrdCl::errInvalidArgs, XrdCl::errInvalidOp, XrdCl::errOSError, GetHeaderTimeout(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, and ts().

Here is the call graph for this function:

Write() [2/2]

XrdCl::XRootDStatus File::Write ( uint64_t offset, XrdCl::Buffer && buffer, XrdCl::ResponseHandler * handler, time_t timeout )

overridevirtual

See also

XrdCl::File::Write

Reimplemented from XrdCl::FilePlugIn.

Definition at line 877 of file XrdClHttpFile.cc.

{
    if (!m_is_opened) {
        m_logger->Error(kLogXrdClHttp, "Cannot write: URL isn't open");
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidOp);
    }
    m_default_prefetch_handler->DisablePrefetch();
 
    auto ts = GetHeaderTimeout(timeout);
    auto url = GetCurrentURL();
    m_logger->Debug(kLogXrdClHttp, "Write %s (%d bytes at offset %lld with timeout %lld)", url.c_str(), static_cast<int>(buffer.GetSize()), static_cast<long long>(offset), static_cast<long long>(ts.tv_sec));
 
    auto handler_wrapper = m_put_handler.load(std::memory_order_relaxed);
    if (!handler_wrapper) {
        handler_wrapper = new PutResponseHandler(handler);
        PutResponseHandler *expected_value = nullptr;
        if (!m_put_handler.compare_exchange_strong(expected_value, handler_wrapper, std::memory_order_acq_rel)) {
            delete handler_wrapper;
            return expected_value->QueueWrite(std::move(buffer), handler);
        }
 
        if (offset != 0) {
            m_put_handler.store(nullptr, std::memory_order_release);
            delete handler_wrapper;
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidArgs, 0, "HTTP uploads must start at offset 0");
        }
        m_put_op.reset(new XrdClHttp::CurlPutOp(
            handler_wrapper, m_default_put_handler, url, std::move(buffer), ts, m_logger,
            GetConnCallout(), &m_default_header_callout
        ));
        handler_wrapper->SetOp(m_put_op);
        m_put_offset.fetch_add(buffer.GetSize(), std::memory_order_acq_rel);
        try {
            m_queue->Produce(m_put_op);
        } catch (...) {
            m_put_handler.store(nullptr, std::memory_order_release);
            delete handler_wrapper;
            m_logger->Warning(kLogXrdClHttp, "Failed to add put op to queue");
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errOSError);
        }
        return XrdCl::XRootDStatus();
    }
 
    auto old_offset = m_put_offset.fetch_add(buffer.GetSize(), std::memory_order_acq_rel);
    if (static_cast<off_t>(offset) != old_offset) {
        m_put_offset.fetch_sub(buffer.GetSize(), std::memory_order_acq_rel);
        m_logger->Warning(kLogXrdClHttp, "Requested write offset at %lld does not match current file descriptor offset at %lld",
            static_cast<long long>(offset), static_cast<long long>(old_offset));
        return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInvalidArgs, 0, "Requested write offset does not match current offset");
    }
    return handler_wrapper->QueueWrite(std::move(buffer), handler);
}

References XrdCl::errInvalidArgs, XrdCl::errInvalidOp, XrdCl::errOSError, GetHeaderTimeout(), XrdClHttp::kLogXrdClHttp, XrdCl::stError, and ts().

Here is the call graph for this function:

---

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

• XrdClHttpFile.hh
• XrdClHttpFile.cc