PathResolver Class Reference

#include <PathResolver.h>

Collaboration diagram for PathResolver:

Public Member Functions
	PathResolver ()=default

Static Public Member Functions
static std::string	find_file (const std::string &logical_file_name, const std::string &search_path)
static std::string	find_file_from_list (const std::string &logical_file_name, const std::string &search_list)
static std::string	find_directory (const std::string &logical_file_name, const std::string &search_path)
static std::string	find_directory_from_list (const std::string &logical_file_name, const std::string &search_list)
static std::string	find_calib_file (const std::string &logical_file_name)
static std::string	find_calib_directory (const std::string &logical_file_name)
static void	setOutputLevel (MSG::Level level)
static void	SetOutputLevel (int lvl)
static std::string	FindCalibFile (const std::string &logical_file_name)
static std::string	FindCalibDirectory (const std::string &logical_file_name)

Static Private Member Functions
static bool	PR_find (const std::string &logical_file_name, const std::string &search_list, std::filesystem::file_type file_type, std::string &result)
	Main private search method used by all public methods. More...
static bool	msgLvl (const MSG::Level lvl)
static MsgStream &	msg ()
static MsgStream &	msg (const MSG::Level lvl)
static asg::AsgMessaging &	asgMsg ()

Static Private Attributes
static std::atomic< MSG::Level >	m_level {MSG::INFO}

Detailed Description

Definition at line 15 of file PathResolver.h.

Constructor & Destructor Documentation

PathResolver()

PathResolver::PathResolver ( )

default

Member Function Documentation

asgMsg()

asg::AsgMessaging & PathResolver::asgMsg ( )

staticprivate

In AnalysisBase this method is not available

Definition at line 79 of file PathResolver.cxx.

                                      {
#ifdef XAOD_STANDALONE
   static thread_local asg::AsgMessaging asgMsg("PathResolver");
#else
   static asg::AsgMessaging asgMsg ATLAS_THREAD_SAFE ("PathResolver");
#endif
#ifndef XAOD_ANALYSIS
   asgMsg.setLevel(m_level);   
#else
   asgMsg.msg().setLevel(m_level);
#endif
   return asgMsg;
}

find_calib_directory()

std::string PathResolver::find_calib_directory ( const std::string &  logical_file_name )

static

Definition at line 257 of file PathResolver.cxx.

{
  checkForDev(asgMsg(), logical_file_name);
 
  std::string out = PathResolver::find_directory (logical_file_name, "CALIBPATH");
  if (out.empty()) {
    msg(MSG::WARNING) << "Could not locate " << logical_file_name << endmsg;
  }
  return out;
}

find_calib_file()

std::string PathResolver::find_calib_file ( const std::string &  logical_file_name )

static

Definition at line 235 of file PathResolver.cxx.

{
  checkForDev(asgMsg(), logical_file_name);
 
  if (logical_file_name.starts_with("root://")) {
    //xrootd access .. try to open file ...
    std::unique_ptr<TFile> fTmp{TFile::Open(logical_file_name.c_str())};
    if (!fTmp || fTmp->IsZombie()) {
      msg(MSG::WARNING) << "Could not open " << logical_file_name << endmsg;
      return {};
    }
    return logical_file_name;
  }
 
  std::string out = PathResolver::find_file (logical_file_name, "CALIBPATH");
  if (out.empty()) {
    msg(MSG::WARNING) << "Could not locate " << logical_file_name << endmsg;
  }
  return out;
}

find_directory()

std::string PathResolver::find_directory ( const std::string &  logical_file_name, const std::string &  search_path  )

static

• logical_file_name the name of the directory to locate in the search path
• search_path the name of a path-like environment variable

Returns

the physical name of the located directory or empty string if not found

Definition at line 212 of file PathResolver.cxx.

{
  const char* path_list = std::getenv(search_path.c_str());
  if(path_list == nullptr) {
    msg(MSG::ERROR) << search_path  << " environment variable not defined!" << endmsg;
    return {};
  }
 
  return find_directory_from_list(logical_file_name, path_list);
}

find_directory_from_list()

std::string PathResolver::find_directory_from_list ( const std::string &  logical_file_name, const std::string &  search_list  )

static

• logical_file_name the name of the directory to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator

Returns

the physical name of the located directory or empty string if not found

Definition at line 225 of file PathResolver.cxx.

{
  std::string result;
  PR_find(logical_file_name, search_list, fs::file_type::directory, result);
 
  return result;
}

find_file()

std::string PathResolver::find_file ( const std::string &  logical_file_name, const std::string &  search_path  )

static

• logical_file_name the name of the file to locate in the search path
• search_path the name of a path-like environment variable

Returns

the physical name of the located file or empty string if not found

Definition at line 183 of file PathResolver.cxx.

                                                                  {
 
#ifndef XAOD_ANALYSIS
  if (logical_file_name.starts_with('/')) {
    msg(MSG::ERROR) << "Use of an absolute file name: " << logical_file_name << endmsg;
  }
#endif
 
  const char* path_list = std::getenv(search_path.c_str());
  if (path_list == nullptr) {
    msg(MSG::ERROR) << search_path << " environment variable not defined!" << endmsg;
    return {};
  }
 
  return find_file_from_list(logical_file_name, path_list);
}

find_file_from_list()

std::string PathResolver::find_file_from_list ( const std::string &  logical_file_name, const std::string &  search_list  )

static

• logical_file_name the name of the file to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator

Returns

the physical name of the located file or empty string if not found

Definition at line 202 of file PathResolver.cxx.

{
  std::string result;
  PR_find (logical_file_name, search_list, fs::file_type::regular, result);
 
  return result;
}

FindCalibDirectory()

static std::string PathResolver::FindCalibDirectory ( const std::string &  logical_file_name )

inlinestatic

Definition at line 64 of file PathResolver.h.

{ return find_calib_directory(logical_file_name); }

FindCalibFile()

static std::string PathResolver::FindCalibFile ( const std::string &  logical_file_name )

inlinestatic

Definition at line 63 of file PathResolver.h.

{ return find_calib_file(logical_file_name); }

msg() [1/2]

static MsgStream& PathResolver::msg ( )

inlinestaticprivate

Definition at line 73 of file PathResolver.h.

{ return asgMsg().msg(); }

msg() [2/2]

static MsgStream& PathResolver::msg ( const MSG::Level  lvl )

inlinestaticprivate

Definition at line 74 of file PathResolver.h.

{ return asgMsg().msg(lvl); }

msgLvl()

static bool PathResolver::msgLvl ( const MSG::Level  lvl )

inlinestaticprivate

Definition at line 72 of file PathResolver.h.

{ return asgMsg().msgLvl(lvl); }

PR_find()

bool PathResolver::PR_find ( const std::string &  logical_file_name, const std::string &  search_list, std::filesystem::file_type  file_type, std::string &  result  )

staticprivate

Main private search method used by all public methods.

Definition at line 98 of file PathResolver.cxx.

                                                                       {
 
  // expand filename before finding
  TString tmpString(logical_file_name);
  gSystem->ExpandPathName(tmpString);
 
  fs::path file(tmpString.Data());
  fs::path locationToDownloadTo = "."; // will replace with first search location
 
  // First always search for filename as given in local directory
  const std::string searchPath = std::format("./{}{}", path_separator, search_list);
 
  // iterate through search list
  for (const auto r : searchPath | std::views::split(path_separator)) {
    std::string_view path(r.begin(), r.end());
    const bool is_http = path.starts_with("http//");
    if( (is_http || path.starts_with("https//")) &&
        file_type==fs::file_type::regular && std::getenv("PATHRESOLVER_ALLOWHTTPDOWNLOAD") ) { // only http download files, not directories
 
      // Try to do an http download to the local location.
      // Need to restore the proper http protocol (cannot use ":" in search paths)
      const std::string fileToDownload = std::format("{}://{}/{}", is_http ? "http" : "https",
                                                     path.substr(6), file.string());
 
      const fs::path targetPath = locationToDownloadTo / file;
      fs::path targetDir = targetPath;
      targetDir.remove_filename();
      msg(MSG::DEBUG) << "Attempting http download of " << fileToDownload << " to " << targetDir << endmsg;
 
      if (!is_directory(targetDir)) {
        msg(MSG::DEBUG) << "Creating directory " << targetDir  << endmsg;
        if(!fs::create_directories(targetDir)) {
          msg(MSG::ERROR) << "Unable to create directories to write file to " << targetDir << endmsg;
          return false;
        }
      }
 
      if (!TFile::Cp(fileToDownload.c_str(), targetPath.c_str(), false)) {
        msg(MSG::INFO) << "Unable to download file "
                       << fileToDownload
                       << " with ROOT, falling back to command line tools"
                       << endmsg;
        if (download_with_curl(fileToDownload, targetPath)) {
          msg(MSG::INFO) << "Successfully curled " << fileToDownload << endmsg;
          result = targetPath;
          return true;
        } else {
          msg(MSG::WARNING) << "Unable to download file "
                            << fileToDownload
                            << endmsg;
        }
      } else {
        msg(MSG::DEBUG) << "Successfully downloaded " << fileToDownload << endmsg;
        result = targetPath;
        return true;
      }
 
    } else if (locationToDownloadTo==".") {
      // Prefer first non-pwd location (usually local build area) for downloading to.
      fs::path dummyFile = fs::path(path) / "._pathresolver_dummy";
      std::ofstream ofs(dummyFile);   // check if writable
      if (ofs.is_open()) {
        locationToDownloadTo = path;
        ofs.close();
        fs::remove(dummyFile);
      }
    }
 
    fs::path fp = path / file;
    try {
      if (fs::status(fp).type() == file_type) {
        result = fs::absolute(fp).string();
        return true;
      }
    } catch (const fs::filesystem_error&) {
      // file not accessible or does not exist
    }
 
  }
 
  return false; // not found
}

SetOutputLevel()

static void PathResolver::SetOutputLevel ( int  lvl )

inlinestatic

Definition at line 61 of file PathResolver.h.

{ setOutputLevel(MSG::Level(lvl)); }

setOutputLevel()

void PathResolver::setOutputLevel ( MSG::Level  level )

static

Definition at line 269 of file PathResolver.cxx.

                                                {
   m_level = level;
}

Member Data Documentation

m_level

std::atomic<MSG::Level> PathResolver::m_level {MSG::INFO}

inlinestaticprivate

Definition at line 71 of file PathResolver.h.

---

The documentation for this class was generated from the following files:

• PathResolver.h
• PathResolver.cxx