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.
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::NIL}

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

Definition at line 129 of file PathResolver.cxx.

                                      {
 
#ifdef XAOD_STANDALONE
   static thread_local asg::AsgMessaging asgMsg("PathResolver");
#else
   static asg::AsgMessaging asgMsg ATLAS_THREAD_SAFE ("PathResolver");
#endif
 
   // Set default OutputLevel unless user already set one
   if (m_level==MSG::NIL) setOutputLevel(MSG::INFO);
 
   return asgMsg;
}

find_calib_directory()

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

static

Definition at line 294 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 272 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 249 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 262 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 220 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 239 of file PathResolver.cxx.

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

FindCalibDirectory()

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()

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]

MsgStream & PathResolver::msg ( )

inlinestaticprivate

Definition at line 73 of file PathResolver.h.

{ return asgMsg().msg(); }

msg() [2/2]

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

inlinestaticprivate

Definition at line 74 of file PathResolver.h.

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

msgLvl()

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 147 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();
      if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Attempting http download of " << fileToDownload << " to " << targetDir << endmsg;
 
      if (!is_directory(targetDir)) {
        if (msgLvl(MSG::DEBUG)) 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 (!download_file(fileToDownload, targetPath, asgMsg())) {
        msg(MSG::WARNING) << "Unable to download file " << fileToDownload << endmsg;
      } else {
        if (msgLvl(MSG::DEBUG)) 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()

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 306 of file PathResolver.cxx.

                                                {
   m_level = level;
#ifndef XAOD_ANALYSIS
   asgMsg().setLevel(m_level);
#else
   asgMsg().msg().setLevel(m_level);
#endif
}

Member Data Documentation

m_level

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

inlinestaticprivate

Definition at line 71 of file PathResolver.h.

{MSG::NIL};

---

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

• PathResolver.h
• PathResolver.cxx