QueryAttrHandler Class Reference

Inheritance diagram for QueryAttrHandler:

Classes
struct	QueryAttrState

Public Member Functions
QueryAttrHandler &	operator= (const QueryAttrHandler &)=delete
	QueryAttrHandler ()=delete
	QueryAttrHandler (const QueryAttrHandler &)=delete
	QueryAttrHandler (const std::string &url)
	~QueryAttrHandler () override=default

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

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

Private Attributes
XrdCl::FileSystem	m_fs
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 82 of file XrdSource.cc.

Constructor & Destructor Documentation

QueryAttrHandler() [1/3]

QueryAttrHandler::QueryAttrHandler ( )

delete

~QueryAttrHandler()

QueryAttrHandler::~QueryAttrHandler ( )

overridedefault

QueryAttrHandler() [2/3]

QueryAttrHandler::QueryAttrHandler ( const QueryAttrHandler &  )

delete

QueryAttrHandler() [3/3]

QueryAttrHandler::QueryAttrHandler ( const std::string &  url )

inline

Definition at line 91 of file XrdSource.cc.

: m_fs(url) {}

Member Function Documentation

HandleResponse()

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

inlineoverrideprivate

Definition at line 127 of file XrdSource.cc.

References uploadConditions::response, and mps_update::status.

                                                                                    {
    // 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 = std::make_unique<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);
    }
  }

operator=()

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

delete

query()

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

inlinestatic

Definition at line 93 of file XrdSource.cc.

References helper::Config, mps_fire::result, and relmon_authenticated_wget::url.

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

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

    XrdCl::XRootDStatus st = handler->m_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::make_unique

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

friend

Member Data Documentation

m_fs

XrdCl::FileSystem QueryAttrHandler::m_fs

private

Definition at line 180 of file XrdSource.cc.

m_state

std::weak_ptr<QueryAttrState> QueryAttrHandler::m_state

private

Definition at line 179 of file XrdSource.cc.