QueryAttrHandler Class Reference

Inheritance diagram for QueryAttrHandler:

Classes
struct	QueryAttrState

Public Member Functions
QueryAttrHandler &	operator= (const QueryAttrHandler &)=delete
	QueryAttrHandler (const QueryAttrHandler &)=delete
	~QueryAttrHandler () override=default

Static Public Member Functions
static XrdCl::XRootDStatus	query (XrdCl::FileSystem &fs, const std::string &attr, std::chrono::milliseconds timeout, std::string &result)

Private Member Functions
void	HandleResponse (XrdCl::XRootDStatus *status, XrdCl::AnyObject *response) override
	QueryAttrHandler ()

Private Attributes
std::weak_ptr< QueryAttrState >	m_state

Friends
std::unique_ptr< QueryAttrHandler >	std::make_unique ()

Detailed Description

A handler for querying a XrdCl::FileSystem object which is safe to be invoked from an XrdCl callback (that is, we don't need an available callback thread to timeout).

Definition at line 88 of file XrdSource.cc.

Constructor & Destructor Documentation

QueryAttrHandler::~QueryAttrHandler ( )

overridedefault

QueryAttrHandler::QueryAttrHandler ( const QueryAttrHandler &  )

delete

QueryAttrHandler::QueryAttrHandler ( )

inlineprivate

Definition at line 137 of file XrdSource.cc.

{}

Member Function Documentation

void QueryAttrHandler::HandleResponse ( XrdCl::XRootDStatus *  status, XrdCl::AnyObject *  response  )

inlineoverrideprivate

Definition at line 140 of file XrdSource.cc.

    {
        // NOTE: we own the status and response pointers.
        std::unique_ptr<XrdCl::AnyObject> response_mgr;
        response_mgr.reset(response);

        // Lock our state information then dispose of our object.
        auto l_state = m_state.lock();
        delete this;
        if (!l_state) {return;}

        // On function exit, notify any waiting threads.
        std::unique_ptr<char, std::function<void(char*)>> notify_guard(nullptr, [&](char *) {l_state->m_condvar.notify_all();});

        {
            // On exit from the block, make sure m_status is set; it needs to be set before we notify threads.
            std::unique_ptr<char, std::function<void(char*)>> exit_guard(nullptr, [&](char *) {if (!l_state->m_status) l_state->m_status.reset(new XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errInternal));});
            if (!status) {return;}
            if (status->IsOK())
            {
                if (!response) {return;}
                XrdCl::Buffer *buf_ptr;
                response->Get(buf_ptr);
                // AnyObject::Set lacks specialization for nullptr
                response->Set(static_cast<int *>(nullptr));
                l_state->m_response.reset(buf_ptr);
            }
            l_state->m_status.reset(status);
        }
    }

QueryAttrHandler& QueryAttrHandler::operator= ( const QueryAttrHandler &  )

delete

static XrdCl::XRootDStatus QueryAttrHandler::query ( XrdCl::FileSystem &  fs, const std::string &  attr, std::chrono::milliseconds  timeout, std::string &  result  )

inlinestatic

Definition at line 99 of file XrdSource.cc.

Referenced by XrdAdaptor::Source::getXrootdSiteFromURL().

    {
        auto handler = std::make_unique<QueryAttrHandler>();
        auto l_state = std::make_shared<QueryAttrState>();
        handler->m_state = l_state;
        XrdCl::Buffer arg(attr.size());
        arg.FromString(attr);

        XrdCl::XRootDStatus st = fs.Query(XrdCl::QueryCode::Config, arg, handler.get());
        if (!st.IsOK())
        {
            return st;
        }

        // Successfully registered the callback; it will always delete itself, so we shouldn't.
        handler.release();

        std::unique_lock<std::mutex> guard(l_state->m_mutex);
        // Wait until some status is available or a timeout.
        l_state->m_condvar.wait_for(guard, timeout, [&]{return l_state->m_status.get();});

        if (l_state->m_status)
        {
            if (l_state->m_status->IsOK())
            {
                result = l_state->m_response->ToString();
            }
            return *(l_state->m_status);
        }
        else
        {   // We had a timeout; construct a reasonable message.
            return XrdCl::XRootDStatus(XrdCl::stError, XrdCl::errSocketTimeout, 1, "Timeout when waiting for query callback.");
        }
    }

Friends And Related Function Documentation

std::unique_ptr<QueryAttrHandler> std::make_unique ( )

friend

Member Data Documentation

std::weak_ptr<QueryAttrState> QueryAttrHandler::m_state

private

Definition at line 186 of file XrdSource.cc.