XrdAdaptor::RequestManager::OpenHandler Class Reference

Inheritance diagram for XrdAdaptor::RequestManager::OpenHandler:

Public Member Functions
std::string	current_source ()
virtual void	HandleResponseWithHosts (XrdCl::XRootDStatus *status, XrdCl::AnyObject *response, XrdCl::HostList *hostList) override
std::shared_future < std::shared_ptr< Source > >	open ()
	~OpenHandler ()

Static Public Member Functions
static std::shared_ptr < OpenHandler >	getInstance (std::weak_ptr< RequestManager > manager)

Private Member Functions
	OpenHandler (std::weak_ptr< RequestManager > manager)

Private Attributes
std::unique_ptr< XrdCl::File >	m_file
std::weak_ptr< RequestManager >	m_manager
std::recursive_mutex	m_mutex
std::promise< std::shared_ptr < Source > >	m_promise
std::shared_ptr< OpenHandler >	m_self
std::weak_ptr< OpenHandler >	m_self_weak
std::shared_future < std::shared_ptr< Source > >	m_shared_future

Detailed Description

Definition at line 220 of file XrdRequestManager.h.

Constructor & Destructor Documentation

XrdAdaptor::RequestManager::OpenHandler::~OpenHandler

(

)

Definition at line 1000 of file XrdRequestManager.cc.

{
}

XrdAdaptor::RequestManager::OpenHandler::OpenHandler ( std::weak_ptr< RequestManager >  manager )

private

Definition at line 992 of file XrdRequestManager.cc.

Referenced by getInstance().

  : m_manager(manager)
{
}

Member Function Documentation

std::string XrdAdaptor::RequestManager::OpenHandler::current_source

(

)

Returns the current source server name. Useful primarily for debugging.

Definition at line 1060 of file XrdRequestManager.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

{
    std::lock_guard<std::recursive_mutex> sentry(m_mutex);

    if (!m_file.get())
    {
        return "(no open in progress)";
    }
    std::string dataServer;
    m_file->GetProperty("DataServer", dataServer);
    if (!dataServer.size()) { return "(unknown source)"; }
    return dataServer;
}

static std::shared_ptr<OpenHandler> XrdAdaptor::RequestManager::OpenHandler::getInstance ( std::weak_ptr< RequestManager >  manager )

inlinestatic

Definition at line 224 of file XrdRequestManager.h.

References instance, m_self_weak, and OpenHandler().

Referenced by XrdAdaptor::RequestManager::initialize().

        {
            OpenHandler *instance_ptr = new OpenHandler(manager);
            std::shared_ptr<OpenHandler> instance(instance_ptr);
            instance_ptr->m_self_weak = instance;
            return instance;
        }

void XrdAdaptor::RequestManager::OpenHandler::HandleResponseWithHosts ( XrdCl::XRootDStatus *  status, XrdCl::AnyObject *  response, XrdCl::HostList *  hostList  )

overridevirtual

Handle the file-open response

Definition at line 1006 of file XrdRequestManager.cc.

References cms::Exception::addContext(), TauDecayModes::dec, XrdAdaptor::Source::determineHostExcludeString(), edm::errors::FileOpenError, GET_CLOCK_MONOTONIC, eostools::move(), fileCollector::now, SendMonitoringInfo(), source, popcon_last_value_cfg::Source, ntuplemaker::status, and AlCaHLTBitMon_QueryRunRegistry::string.

{
  std::shared_ptr<Source> source;
  std::unique_ptr<XrdCl::XRootDStatus> status(status_ptr);
  std::unique_ptr<XrdCl::HostList> hostList(hostList_ptr);

    // Make sure we get rid of the strong self-reference when the callback finishes.
  std::shared_ptr<OpenHandler> self = m_self;
  m_self.reset();

  auto manager = m_manager.lock();
    // Manager object has already been deleted.  Cleanup the
    // response objects, remove our self-reference, and ignore the response.
  if (!manager)
  {
    return;
  }
  //if we need to delete the File object we must do it outside
  // of the lock to avoid a potential deadlock
  std::unique_ptr<XrdCl::File> releaseFile;
  {
    std::lock_guard<std::recursive_mutex> sentry(m_mutex);

    if (status->IsOK())
    {
        SendMonitoringInfo(*m_file);
        timespec now;
        GET_CLOCK_MONOTONIC(now);

        std::string excludeString;
        Source::determineHostExcludeString(*m_file, hostList.get(), excludeString);

        source.reset(new Source(now, std::move(m_file), excludeString));
        m_promise.set_value(source);
    }
    else
    {
        releaseFile = std::move(m_file);
        edm::Exception ex(edm::errors::FileOpenError);
        ex << "XrdCl::File::Open(name='" << manager->m_name
           << "', flags=0x" << std::hex << manager->m_flags
           << ", permissions=0" << std::oct << manager->m_perms << std::dec
           << ") => error '" << status->ToStr()
           << "' (errno=" << status->errNo << ", code=" << status->code << ")";
        ex.addContext("In XrdAdaptor::RequestManager::OpenHandler::HandleResponseWithHosts()");
        manager->addConnections(ex);

        m_promise.set_exception(std::make_exception_ptr(ex));
    }
  }
  manager->handleOpen(*status, source);
}

std::shared_future< std::shared_ptr< Source > > XrdAdaptor::RequestManager::OpenHandler::open

(

)

Future-based version of the handler If called while a file-open is in progress, we will not start a new file-open. Instead, the callback will be fired for the ongoing open.

NOTE NOTE: This function is not thread-safe due to a lock-ordering issue. The caller must ensure it is not called from multiple threads at once for this object.

Definition at line 1075 of file XrdRequestManager.cc.

References XrdAdaptor::RequestManager::addConnections(), cms::Exception::addContext(), TauDecayModes::dec, reco_application_tbsim_DetSim-Digi_cfg::File, edm::errors::FileOpenError, edm::errors::LogicError, XrdAdaptor::RequestManager::m_flags, XrdAdaptor::RequestManager::m_name, XrdAdaptor::RequestManager::m_perms, XrdAdaptor::RequestManager::prepareOpaqueString(), ntuplemaker::status, and AlCaHLTBitMon_QueryRunRegistry::string.

{
    auto manager_ptr = m_manager.lock();
    if (!manager_ptr)
    {
      edm::Exception ex(edm::errors::LogicError);
      ex << "XrdCl::File::Open() =>"
         << " error: OpenHandler called within an invalid RequestManager context."
         << "  This is a logic error and should be reported to the CMSSW developers.";
      ex.addContext("Calling XrdAdaptor::RequestManager::OpenHandler::open()");
      throw ex;
    }
    RequestManager &manager = *manager_ptr;
    auto self_ptr = m_self_weak.lock();
    if (!self_ptr)
    {
      edm::Exception ex(edm::errors::LogicError);
      ex << "XrdCl::File::Open() => error: "
         << "OpenHandler called after it was deleted.  This is a logic error "
         << "and should be reported to the CMSSW developers.";
      ex.addContext("Calling XrdAdapter::RequestManager::OpenHandler::open()");
      throw ex;
    }

      // NOTE NOTE: we look at this variable *without* the lock.  This means the method
      // is not thread-safe; the caller is responsible to verify it is not called from
      // multiple threads simultaneously.
      //
      // This is done because ::open may be called from a Xrootd callback; if we
      // tried to hold m_mutex here, this object's callback may also be active, hold m_mutex,
      // and make a call into xrootd (when it invokes m_file.reset()).  Hence, our callback
      // holds our mutex and attempts to grab an Xrootd mutex; RequestManager::requestFailure holds
      // an Xrootd mutex and tries to hold m_mutex.  This is a classic deadlock.
    if (m_file.get())
    {
        return m_shared_future;
    }
    std::lock_guard<std::recursive_mutex> sentry(m_mutex);
    std::promise<std::shared_ptr<Source> > new_promise;
    m_promise.swap(new_promise);
    m_shared_future = m_promise.get_future().share();

    auto opaque = manager.prepareOpaqueString();
    std::string new_name = manager.m_name + ((manager.m_name.find("?") == manager.m_name.npos) ? "?" : "&") + opaque;
    edm::LogVerbatim("XrdAdaptorInternal") << "Trying to open URL: " << new_name;
    m_file.reset(new XrdCl::File());
    XrdCl::XRootDStatus status;
    if (!(status = m_file->Open(new_name, manager.m_flags, manager.m_perms, this)).IsOK())
    {
      edm::Exception ex(edm::errors::FileOpenError);
      ex << "XrdCl::File::Open(name='" << new_name
         << "', flags=0x" << std::hex << manager.m_flags
         << ", permissions=0" << std::oct << manager.m_perms << std::dec
         << ") => error '" << status.ToStr()
         << "' (errno=" << status.errNo << ", code=" << status.code << ")";
      ex.addContext("Calling XrdAdaptor::RequestManager::OpenHandler::open()");
      manager.addConnections(ex);
      throw ex;
    }
      // Have a strong self-reference for as long as the callback is in-progress.
    m_self = self_ptr;
    return m_shared_future;
}

Member Data Documentation

std::unique_ptr<XrdCl::File> XrdAdaptor::RequestManager::OpenHandler::m_file

private

Definition at line 262 of file XrdRequestManager.h.

std::weak_ptr<RequestManager> XrdAdaptor::RequestManager::OpenHandler::m_manager

private

Definition at line 270 of file XrdRequestManager.h.

std::recursive_mutex XrdAdaptor::RequestManager::OpenHandler::m_mutex

private

Definition at line 263 of file XrdRequestManager.h.

std::promise<std::shared_ptr<Source> > XrdAdaptor::RequestManager::OpenHandler::m_promise

private

Definition at line 259 of file XrdRequestManager.h.

std::shared_ptr<OpenHandler> XrdAdaptor::RequestManager::OpenHandler::m_self

private

Definition at line 264 of file XrdRequestManager.h.

std::weak_ptr<OpenHandler> XrdAdaptor::RequestManager::OpenHandler::m_self_weak

private

Definition at line 269 of file XrdRequestManager.h.

Referenced by getInstance().

std::shared_future<std::shared_ptr<Source> > XrdAdaptor::RequestManager::OpenHandler::m_shared_future

private

Definition at line 258 of file XrdRequestManager.h.