XrdClHttp::VerbsCache Class Reference

#include <XrdClHttpOptionsCache.hh>

Collaboration diagram for XrdClHttp::VerbsCache:

Classes
class	HttpVerbs

Public Types
enum class	HttpVerb {   kUnset = 0 ,   kUnknown = 1 ,   kPROPFIND = 2 }

Public Member Functions
void	Expire (std::chrono::steady_clock::time_point now)
HttpVerbs	Get (const std::string &url, const std::chrono::steady_clock::time_point &now=std::chrono::steady_clock::now()) const
uint64_t	GetCacheHits () const
uint64_t	GetCacheMisses () const
void	Put (const std::string &url, const HttpVerbs &verbs, const std::chrono::steady_clock::time_point &now=std::chrono::steady_clock::now()) const

Static Public Member Functions
static std::string_view	GetUrlKey (const std::string &url, std::string &modified_url)
static const std::string	GetVerbString (HttpVerb ctype)
static VerbsCache &	Instance ()

Detailed Description

Definition at line 37 of file XrdClHttpOptionsCache.hh.

Member Enumeration Documentation

HttpVerb

enum XrdClHttp::VerbsCache::HttpVerb

strong

Enumerator
kUnset
kUnknown
kPROPFIND

Definition at line 41 of file XrdClHttpOptionsCache.hh.

                        {
        kUnset = 0, // Indicates that we haven't yet probed for the HTTP verb support.
        kUnknown = 1, // Indicates we probed for support but the result was indeterminate (not provided by the server, network error)
        kPROPFIND = 2, // Server claims to support PROPFIND
    };

Member Function Documentation

Expire()

void XrdClHttp::VerbsCache::Expire

(

std::chrono::steady_clock::time_point

now

)

Definition at line 67 of file XrdClHttpOptionsCache.cc.

{
    std::unique_lock lock(m_mutex);
    for (auto iter = m_verbs_map.begin(); iter != m_verbs_map.end();) {
        if (iter->second.m_expiry < now) {
            iter = m_verbs_map.erase(iter);
        } else {
            ++iter;
        }
    }
}

Get()

HttpVerbs XrdClHttp::VerbsCache::Get ( const std::string &  url, const std::chrono::steady_clock::time_point &  now = std::chrono::steady_clock::now()  ) const

inline

Definition at line 95 of file XrdClHttpOptionsCache.hh.

                                                                                                                     {
        std::string modified_url;
        auto key = GetUrlKey(url, modified_url);
 
        const std::shared_lock sentry(m_mutex);
#if __cplusplus >= 202002L
        auto iter = m_verbs_map.find(key);
#else
        auto iter = m_verbs_map.find(std::string(key));
#endif
        if (iter == m_verbs_map.end()) {
            m_cache_miss++;
            return HttpVerbs{};
        }
        if (iter->second.m_expiry < now) {
            m_cache_miss++;
            return HttpVerbs{};
        }
        m_cache_hit++;
        return iter->second.m_verbs;
    }

References GetUrlKey().

Here is the call graph for this function:

GetCacheHits()

uint64_t XrdClHttp::VerbsCache::GetCacheHits ( ) const

inline

Definition at line 140 of file XrdClHttpOptionsCache.hh.

{return m_cache_hit;}

GetCacheMisses()

uint64_t XrdClHttp::VerbsCache::GetCacheMisses ( ) const

inline

Definition at line 141 of file XrdClHttpOptionsCache.hh.

{return m_cache_miss;}

GetUrlKey()

static std::string_view XrdClHttp::VerbsCache::GetUrlKey ( const std::string &  url, std::string &  modified_url  )

inlinestatic

Definition at line 120 of file XrdClHttpOptionsCache.hh.

                                                                                   {
        auto authority_loc = url.find("://");
        if (authority_loc == std::string::npos) {
            return std::string_view();
        }
        auto path_loc = url.find('/', authority_loc + 3);
        if (path_loc == std::string::npos) {
            path_loc = url.length();
        }
 
        std::string_view url_view{url};
        auto host_loc = url_view.substr(authority_loc + 3, path_loc - authority_loc - 3).find('@');
        if (host_loc == std::string::npos) {
            return url_view.substr(0, path_loc);
        }
        host_loc += authority_loc + 3;
        modified_url = url.substr(0, authority_loc + 3) + std::string(url_view.substr(host_loc + 1, path_loc - host_loc - 1));
        return modified_url;
    }

Referenced by Get(), Put(), and XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

GetVerbString()

static const std::string XrdClHttp::VerbsCache::GetVerbString ( HttpVerb  ctype )

inlinestatic

Definition at line 61 of file XrdClHttpOptionsCache.hh.

                                                         {
        switch (ctype) {
            case HttpVerb::kUnset:
                return "(unset)";
            case HttpVerb::kUnknown:
                return "(unknown)";
            case HttpVerb::kPROPFIND:
                return "PROPFIND";
        }
    }

References kPROPFIND, kUnknown, and kUnset.

Instance()

XrdClHttp::VerbsCache & XrdClHttp::VerbsCache::Instance ( )

static

Definition at line 37 of file XrdClHttpOptionsCache.cc.

                                                    {
    std::unique_lock lk(m_shutdown_lock);
    if (!m_shutdown_requested) {
        std::call_once(m_expiry_launch, [] {
            std::thread t(VerbsCache::ExpireThread);
            m_expire_tid = std::move(t);
        });
    }
    return g_cache;
}

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

Here is the caller graph for this function:

Put()

void XrdClHttp::VerbsCache::Put ( const std::string &  url, const HttpVerbs &  verbs, const std::chrono::steady_clock::time_point &  now = std::chrono::steady_clock::now()  ) const

inline

Definition at line 72 of file XrdClHttpOptionsCache.hh.

                                                                                                                                        {
        std::string modified_url;
        auto key = GetUrlKey(url, modified_url);
 
        const std::unique_lock sentry(m_mutex);
 
        auto isKnown = !verbs.IsSet(HttpVerb::kUnknown);
        auto lifetime = isKnown ? g_expiry_duration : g_negative_expiry_duration;
 
// C++20 can elide the allocation for the string_view
#if __cplusplus >= 202002L
        auto iter = m_verbs_map.find(key);
#else
        auto iter = m_verbs_map.find(std::string(key));
#endif
        if (iter == m_verbs_map.end()) {
            m_verbs_map.emplace(key, VerbEntry{now + lifetime, verbs});
        } else if (isKnown || iter->second.m_verbs.IsSet(HttpVerb::kUnknown)) {
            // Previous entry didn't know the verbs, but now we do
            iter->second = {now + lifetime, verbs};
        }
    }

References GetUrlKey(), XrdClHttp::VerbsCache::HttpVerbs::IsSet(), and kUnknown.

Here is the call graph for this function:

---

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

• XrdClHttpOptionsCache.hh
• XrdClHttpOptionsCache.cc