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 77 of file XrdSource.cc.

Constructor & Destructor Documentation

~QueryAttrHandler()

QueryAttrHandler::~QueryAttrHandler ( )

overridedefault

QueryAttrHandler() [1/2]

QueryAttrHandler::QueryAttrHandler ( const QueryAttrHandler &  )

delete

QueryAttrHandler() [2/2]

QueryAttrHandler::QueryAttrHandler ( )

inlineprivate

Definition at line 119 of file XrdSource.cc.

{}

Member Function Documentation

HandleResponse()

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

inlineoverrideprivate

Definition at line 121 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);
    }
  }

References HiBiasedCentrality_cfi::function, mps_update::status, and funct::void.

operator=()

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

delete

query()

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

inlinestatic

Definition at line 85 of file XrdSource.cc.

                                                      {
    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.");
    }
  }

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

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

Friends And Related Function Documentation

std::make_unique

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

friend

Member Data Documentation

m_state

std::weak_ptr<QueryAttrState> QueryAttrHandler::m_state

private

Definition at line 173 of file XrdSource.cc.