Inheritance diagram for XrdAdaptor::RequestManager::OpenHandler:

Public Member Functions
std::string	current_source ()

void	HandleResponseWithHosts (XrdCl::XRootDStatus status, XrdCl::AnyObject response, XrdCl::HostList *hostList) override

std::shared_future< std::shared_ptr< Source > >	open ()

	~OpenHandler () override

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::atomic< bool >	m_outstanding_open {false}

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 241 of file XrdRequestManager.h.

Constructor & Destructor Documentation

XrdAdaptor::RequestManager::OpenHandler::~OpenHandler ( )

override

Definition at line 965 of file XrdRequestManager.cc.

965 {}

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

private

Definition at line 961 of file XrdRequestManager.cc.

961 : m_manager(manager) {}

XrdAdaptor::RequestManager::OpenHandler::m_manager

std::weak_ptr< RequestManager > m_manager

Definition: XrdRequestManager.h:294

Member Function Documentation

std::string XrdAdaptor::RequestManager::OpenHandler::current_source ( )

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

Definition at line 1021 of file XrdRequestManager.cc.

References m_file, m_mutex, and 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.empty()) {
     return "(unknown source)";
   }
   return dataServer;
 }

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

inlinestatic

Definition at line 245 of file XrdRequestManager.h.

References instance, m_self_weak, and AlCaHLTBitMon_QueryRunRegistry::string.

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
	)

override

Handle the file-open response

Definition at line 967 of file XrdRequestManager.cc.

References cms::Exception::addContext(), TauDecayModes::dec, XrdAdaptor::Source::determineHostExcludeString(), edm::errors::FileOpenError, GET_CLOCK_MONOTONIC, m_file, m_manager, m_mutex, m_outstanding_open, m_promise, m_self, eostools::move(), cmsPerfSuiteHarvest::now, SendMonitoringInfo(), PFJetToCaloProducer_cfi::Source, source, mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                    {
   // Make sure we get rid of the strong self-reference when the callback finishes.
   std::shared_ptr<OpenHandler> self = m_self;
   m_self.reset();
 
   // NOTE: as in XrdCl::File (synchronous), we ignore the response object.
   // Make sure that we set m_outstanding_open to false on exit from this function.
   // NOTE: we need to pass non-nullptr to unique_ptr in order for the guard to run
   std::unique_ptr<OpenHandler, std::function<void(OpenHandler *)>> outstanding_guard(
       this, [&](OpenHandler *) { m_outstanding_open = false; });
 
   std::shared_ptr<Source> source;
   std::unique_ptr<XrdCl::XRootDStatus> status(status_ptr);
   std::unique_ptr<XrdCl::HostList> hostList(hostList_ptr);
 
   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 1035 of file XrdRequestManager.cc.

References XrdAdaptor::RequestManager::addConnections(), cms::Exception::addContext(), TauDecayModes::dec, ecalTB2006H4_GenSimDigiReco_cfg::File, edm::errors::FileOpenError, edm::errors::LogicError, m_file, XrdAdaptor::RequestManager::m_flags, m_manager, m_mutex, XrdAdaptor::RequestManager::m_name, m_outstanding_open, XrdAdaptor::RequestManager::m_perms, m_promise, m_self, m_self_weak, m_shared_future, XrdAdaptor::RequestManager::prepareOpaqueString(), mps_update::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_outstanding_open) {
     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());
   m_outstanding_open = true;
 
   // Always make sure we release m_file and set m_outstanding_open to false on error.
   std::unique_ptr<OpenHandler, std::function<void(OpenHandler *)>> exit_guard(this, [&](OpenHandler *) {
     m_outstanding_open = false;
     m_file.reset();
   });
 
   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;
   }
   exit_guard.release();
   // Have a strong self-reference for as long as the callback is in-progress.
   m_self = self_ptr;
   return m_shared_future;
 }